diff --git a/native/CMakeLists.txt b/native/CMakeLists.txt index f20e2fe822..3590222881 100644 --- a/native/CMakeLists.txt +++ b/native/CMakeLists.txt @@ -1,6 +1,6 @@ -if(NOT USE_XR AND NOT USE_AR_MODULE) - include(${CMAKE_CURRENT_LIST_DIR}/cmake/predefine.cmake) -endif() +cmake_minimum_required(VERSION 3.22.1) + +include(${CMAKE_CURRENT_LIST_DIR}/cmake/predefine.cmake) ################################# engine source code ################################## set(CWD ${CMAKE_CURRENT_LIST_DIR}) @@ -13,7 +13,24 @@ set(ENGINE_NAME cocos_engine) ################################# options ############################################ # default fallback options cc_set_if_undefined(CC_DEBUG_FORCE OFF) -cc_set_if_undefined(USE_SE_V8 ON) +cc_set_if_undefined(USE_SE_V8 OFF) +cc_set_if_undefined(USE_SE_HERMES ON) +cc_set_if_undefined(USE_V8_DEBUGGER OFF) + +# Dynamically locate React Native JSI headers for Hermes support +if(USE_SE_HERMES) + execute_process( + COMMAND node -e "console.log(require('path').dirname(require.resolve('react-native/package.json')))" + OUTPUT_VARIABLE REACT_NATIVE_DIR + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + set(REACT_NATIVE_JSI_DIR "${REACT_NATIVE_DIR}/ReactCommon/jsi") + if(EXISTS "${REACT_NATIVE_JSI_DIR}") + message(STATUS "Found React Native JSI headers at: ${REACT_NATIVE_JSI_DIR}") + else() + message(FATAL_ERROR "Hermes JSI headers not found at: ${REACT_NATIVE_JSI_DIR}") + endif() +endif() cc_set_if_undefined(USE_SE_SM OFF) cc_set_if_undefined(USE_SE_NAPI OFF) cc_set_if_undefined(USE_SE_JSVM OFF) @@ -3274,18 +3291,26 @@ if(USE_MODULES) add_library(ccgeometry ${ccgeometry_SOURCE_LIST}) target_include_directories(ccmath PRIVATE + ${CWD} ${CWD}/cocos + $<$:${REACT_NATIVE_JSI_DIR}> ) target_include_directories(ccgeometry PRIVATE + ${CWD} ${CWD}/cocos + $<$:${REACT_NATIVE_JSI_DIR}> ) target_include_directories(ccunzip PRIVATE + ${CWD} ${CWD}/external/sources/unzip ${CWD}/external/sources ${CWD}/cocos + $<$:${REACT_NATIVE_JSI_DIR}> ) target_include_directories(cclog PRIVATE + ${CWD} ${CWD}/cocos + $<$:${REACT_NATIVE_JSI_DIR}> ) target_include_directories(ccfilesystem PRIVATE ${CWD} @@ -3293,15 +3318,17 @@ if(USE_MODULES) ${CWD}/external/sources ) target_include_directories(ccutils PRIVATE + ${CWD} ${CWD}/cocos ${CWD}/external/sources + $<$:${REACT_NATIVE_JSI_DIR}> ) target_include_directories(ccbindings PRIVATE + ${CWD} ${CWD}/cocos ${CWD}/cocos/bindings/jswrapper ${CWD}/cocos/editor-support # TODO: refactor include path - ${CWD} - ${CC_EXTERNAL_INCLUDES} + $<$:${REACT_NATIVE_JSI_DIR}> ) target_link_libraries(ccunzip PUBLIC ${ZLIB} @@ -3368,6 +3395,9 @@ if(QNX) list(APPEND COCOS_SOURCE_LIST ${ccqnx_SOURCE_LIST}) endif() +# ── Extended module split ────────────────────────────────────────────────── +include("${CMAKE_CURRENT_LIST_DIR}/CocosModuleSplit.cmake") + add_library(${ENGINE_NAME} ${COCOS_SOURCE_LIST}) if(CMAKE_GENERATOR STREQUAL "Xcode") @@ -3444,6 +3474,7 @@ function(cc_apply_definations target) $<$:SCRIPT_ENGINE_TYPE=2> $<$:SCRIPT_ENGINE_TYPE=5> $<$:SCRIPT_ENGINE_TYPE=6> + $<$:SCRIPT_ENGINE_TYPE=7> $<$,$>:CC_DEBUG=1> $,CC_USE_ADPF=1,CC_USE_ADPF=0> $,CC_USE_GOOGLE_BILLING=1,CC_USE_GOOGLE_BILLING=0> @@ -3553,6 +3584,8 @@ target_include_directories(${ENGINE_NAME} ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos $<$:${CWD}/cocos/bindings/jswrapper> + $<$:${CWD}/cocos/bindings/jswrapper> + $<$:${REACT_NATIVE_JSI_DIR}> PRIVATE ${CC_EXTERNAL_PRIVATE_INCLUDES} ) diff --git a/native/CMakeLists.txt.rej b/native/CMakeLists.txt.rej new file mode 100644 index 0000000000..f5821190fe --- /dev/null +++ b/native/CMakeLists.txt.rej @@ -0,0 +1,102 @@ +diff a/native/CMakeLists.txt b/native/CMakeLists.txt (rejected hunks) +@@ -1,6 +1,6 @@ +-if(NOT USE_XR AND NOT USE_AR_MODULE) +- include(${CMAKE_CURRENT_LIST_DIR}/cmake/predefine.cmake) +-endif() ++cmake_minimum_required(VERSION 3.22.1) ++ ++include(${CMAKE_CURRENT_LIST_DIR}/cmake/predefine.cmake) + + ################################# engine source code ################################## + set(CWD ${CMAKE_CURRENT_LIST_DIR}) +@@ -13,7 +13,24 @@ set(ENGINE_NAME cocos_engine) + ################################# options ############################################ + # default fallback options + cc_set_if_undefined(CC_DEBUG_FORCE OFF) +-cc_set_if_undefined(USE_SE_V8 ON) ++cc_set_if_undefined(USE_SE_V8 OFF) ++cc_set_if_undefined(USE_SE_HERMES ON) ++cc_set_if_undefined(USE_V8_DEBUGGER OFF) ++ ++# Dynamically locate React Native JSI headers for Hermes support ++if(USE_SE_HERMES) ++ execute_process( ++ COMMAND node -e "console.log(require('path').dirname(require.resolve('react-native/package.json')))" ++ OUTPUT_VARIABLE REACT_NATIVE_DIR ++ OUTPUT_STRIP_TRAILING_WHITESPACE ++ ) ++ set(REACT_NATIVE_JSI_DIR "${REACT_NATIVE_DIR}/ReactCommon/jsi") ++ if(EXISTS "${REACT_NATIVE_JSI_DIR}") ++ message(STATUS "Found React Native JSI headers at: ${REACT_NATIVE_JSI_DIR}") ++ else() ++ message(FATAL_ERROR "Hermes JSI headers not found at: ${REACT_NATIVE_JSI_DIR}") ++ endif() ++endif() + cc_set_if_undefined(USE_SE_SM OFF) + cc_set_if_undefined(USE_SE_NAPI OFF) + cc_set_if_undefined(USE_SE_JSVM OFF) +@@ -3274,18 +3291,26 @@ if(USE_MODULES) + add_library(ccgeometry ${ccgeometry_SOURCE_LIST}) + + target_include_directories(ccmath PRIVATE ++ ${CWD} + ${CWD}/cocos ++ $<$:${REACT_NATIVE_JSI_DIR}> + ) + target_include_directories(ccgeometry PRIVATE ++ ${CWD} + ${CWD}/cocos ++ $<$:${REACT_NATIVE_JSI_DIR}> + ) + target_include_directories(ccunzip PRIVATE ++ ${CWD} + ${CWD}/external/sources/unzip + ${CWD}/external/sources + ${CWD}/cocos ++ $<$:${REACT_NATIVE_JSI_DIR}> + ) + target_include_directories(cclog PRIVATE ++ ${CWD} + ${CWD}/cocos ++ $<$:${REACT_NATIVE_JSI_DIR}> + ) + target_include_directories(ccfilesystem PRIVATE + ${CWD} +@@ -3293,15 +3318,17 @@ if(USE_MODULES) + ${CWD}/external/sources + ) + target_include_directories(ccutils PRIVATE ++ ${CWD} + ${CWD}/cocos + ${CWD}/external/sources ++ $<$:${REACT_NATIVE_JSI_DIR}> + ) + target_include_directories(ccbindings PRIVATE ++ ${CWD} + ${CWD}/cocos + ${CWD}/cocos/bindings/jswrapper + ${CWD}/cocos/editor-support # TODO: refactor include path +- ${CWD} +- ${CC_EXTERNAL_INCLUDES} ++ $<$:${REACT_NATIVE_JSI_DIR}> + ) + target_link_libraries(ccunzip PUBLIC + ${ZLIB} +@@ -3368,6 +3395,9 @@ if(QNX) + list(APPEND COCOS_SOURCE_LIST ${ccqnx_SOURCE_LIST}) + endif() + ++# ── Extended module split ────────────────────────────────────────────────── ++include("${CMAKE_CURRENT_LIST_DIR}/CocosModuleSplit.cmake") ++ + add_library(${ENGINE_NAME} ${COCOS_SOURCE_LIST}) + + if(CMAKE_GENERATOR STREQUAL "Xcode") +@@ -3444,6 +3474,7 @@ function(cc_apply_definations target) + $<$:SCRIPT_ENGINE_TYPE=2> + $<$:SCRIPT_ENGINE_TYPE=5> + $<$:SCRIPT_ENGINE_TYPE=6> ++ $<$:SCRIPT_ENGINE_TYPE=7> + $<$,$>:CC_DEBUG=1> + $,CC_USE_ADPF=1,CC_USE_ADPF=0> + $,CC_USE_GOOGLE_BILLING=1,CC_USE_GOOGLE_BILLING=0> diff --git a/native/CocosModuleSplit.cmake b/native/CocosModuleSplit.cmake new file mode 100644 index 0000000000..45d560e832 --- /dev/null +++ b/native/CocosModuleSplit.cmake @@ -0,0 +1,140 @@ +# CocosModuleSplit.cmake +# Splits the Cocos4 engine into logical static libraries by subsystem. +# This makes incremental rebuilds fast and isolates breakage. +# +# Usage: include("${CMAKE_CURRENT_LIST_DIR}/CocosModuleSplit.cmake") +# Place this BEFORE: add_library(${ENGINE_NAME} ${COCOS_SOURCE_LIST}) + +message(STATUS "Executing extended module split...") + +# ── Inject Hermes backend into ccbindings ─────────────────────────────────── +if(USE_SE_HERMES) + target_sources(ccbindings PRIVATE + ${CWD}/cocos/bindings/jswrapper/hermes/Class.cpp + ${CWD}/cocos/bindings/jswrapper/hermes/Object.cpp + ${CWD}/cocos/bindings/jswrapper/hermes/ScriptEngine.cpp + ${CWD}/cocos/bindings/jswrapper/hermes/Utils.cpp + ) +endif() + +# ── Partition sources by directory ───────────────────────────────────────── +set(_ccrenderer_SOURCES) +set(_cc2d3d_SOURCES) +set(_ccscene_SOURCES) +set(_ccphysics_SOURCES) +set(_ccaudio_SOURCES) +set(_ccplatform_SOURCES) +set(_ccapp_SOURCES) +set(_ccmisc_SOURCES) + +foreach(_src IN LISTS COCOS_SOURCE_LIST) + if(_src MATCHES "/cocos/renderer/") + list(APPEND _ccrenderer_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/2d/" OR _src MATCHES "/cocos/3d/") + list(APPEND _cc2d3d_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/scene/") + list(APPEND _ccscene_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/physics/") + list(APPEND _ccphysics_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/audio/") + list(APPEND _ccaudio_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/platform/") + list(APPEND _ccplatform_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/application/" OR _src MATCHES "/cocos/engine/" OR _src MATCHES "/cocos/main/") + list(APPEND _ccapp_SOURCES "${_src}") + elseif(_src MATCHES "/cocos/ui/" OR _src MATCHES "/cocos/network/" OR _src MATCHES "/cocos/editor-support/" OR _src MATCHES "/cocos/profiler/" OR _src MATCHES "/cocos/primitive/" OR _src MATCHES "/cocos/plugins/" OR _src MATCHES "/cocos/gi/" OR _src MATCHES "/cocos/storage/" OR _src MATCHES "/cocos/base/" OR _src MATCHES "/cocos/core/") + list(APPEND _ccmisc_SOURCES "${_src}") + endif() +endforeach() + +# ── Remove split sources from main engine list ────────────────────────────── +if(USE_MODULES) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccrenderer_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_cc2d3d_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccscene_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccphysics_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccaudio_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccplatform_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccapp_SOURCES}) + list(REMOVE_ITEM COCOS_SOURCE_LIST ${_ccmisc_SOURCES}) +endif() + +# ── Create split static libraries ────────────────────────────────────────── +if(USE_MODULES) + if(_ccrenderer_SOURCES) + add_library(ccrenderer STATIC ${_ccrenderer_SOURCES}) + target_include_directories(ccrenderer PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL>) + target_link_libraries(ccrenderer PUBLIC ccmath cclog ccgeometry ccbindings ccfilesystem) + if(ANDROID) + target_link_libraries(ccrenderer PUBLIC android_platform android log) + endif() + endif() + + if(_cc2d3d_SOURCES) + add_library(cc2d3d STATIC ${_cc2d3d_SOURCES}) + target_include_directories(cc2d3d PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL>) + target_link_libraries(cc2d3d PUBLIC ccmath cclog ccgeometry ccbindings ccrenderer) + endif() + + if(_ccscene_SOURCES) + add_library(ccscene STATIC ${_ccscene_SOURCES}) + target_include_directories(ccscene PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL>) + target_link_libraries(ccscene PUBLIC ccmath cclog cc2d3d ccrenderer ccbindings) + endif() + + if(_ccphysics_SOURCES) + add_library(ccphysics STATIC ${_ccphysics_SOURCES}) + target_include_directories(ccphysics PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL>) + target_link_libraries(ccphysics PUBLIC ccmath cclog ccscene) + endif() + + if(_ccaudio_SOURCES) + add_library(ccaudio STATIC ${_ccaudio_SOURCES}) + target_include_directories(ccaudio PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL> + ${CWD}/external/sources/pvmp3dec/include ${CWD}/external/sources/pvmp3dec/src) + target_link_libraries(ccaudio PUBLIC ccmath cclog) + if(ANDROID) + target_link_libraries(ccaudio PUBLIC android_platform android log OpenSLES) + endif() + endif() + + if(_ccplatform_SOURCES) + add_library(ccplatform STATIC ${_ccplatform_SOURCES}) + target_include_directories(ccplatform PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL>) + target_link_libraries(ccplatform PUBLIC ccmath cclog ccbindings ccfilesystem) + if(ANDROID) + target_link_libraries(ccplatform PUBLIC cocos_jni) + endif() + endif() + + if(_ccapp_SOURCES) + add_library(ccapp STATIC ${_ccapp_SOURCES}) + target_include_directories(ccapp PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL>) + target_link_libraries(ccapp PUBLIC + ccmath cclog cc2d3d ccrenderer ccscene ccphysics ccaudio ccplatform ccbindings ccfilesystem + ) + endif() + + if(_ccmisc_SOURCES) + add_library(ccmisc STATIC ${_ccmisc_SOURCES}) + target_include_directories(ccmisc PRIVATE ${CWD} ${CWD}/cocos ${CC_EXTERNAL_INCLUDES} ${CWD}/cocos/bindings/jswrapper + $<$:${REACT_NATIVE_JSI_DIR}> ${CWD}/cocos/renderer ${CWD}/cocos/platform ${CWD}/cocos/renderer/core ${CWD}/cocos/editor-support ${CWD}/cocos/bindings/jswrapper ${SWIG_OUTPUT_ROOT} ${SWIG_OUTPUT_ROOT}/cocos ${CWD}/external/sources/khronos + $<$>:${CWD}/external/sources/EGL> + ${CWD}/external/android/${ANDROID_ABI}/include/freetype) + target_link_libraries(ccmisc PUBLIC ccmath cclog ccfilesystem ccbindings freetype) + endif() +endif() diff --git a/native/build_android/MODULES.txt b/native/build_android/MODULES.txt new file mode 100644 index 0000000000..b218ab4f99 --- /dev/null +++ b/native/build_android/MODULES.txt @@ -0,0 +1,50 @@ +Cocos4 Split Static Libraries +Generated by: build_cocos_split.sh +================================================== + +Each .a file is built from sources under packages/cocos4/native/cocos// +except the core utilities, which come from upstream's USE_MODULES=ON set. + +CORE UTILITIES (upstream module set, always built) + libccmath.a - Math library (vectors, matrices, quaternions, geometry primitives) + libccgeometry.a - Geometry types (Plane, Ray, Sphere, Triangle, Spline, etc.) + libcclog.a - Logging framework + libccunzip.a - ZIP/unzip utility + libccfilesystem.a - File abstraction, path resolution, asset bundles + libccbindings.a - Script engine bindings (sebind, jswrapper glue) + libccutils.a - Misc utilities (base64, memory hooks, threadpool, string utils) + +ENGINE MODULES (split by subsystem directory) + libccrenderer.a - Renderer (262 source files): GFX backends, pipeline, batcher, + scene rendering, debug drawer, frame graph, material system + libcc2d3d.a - 2D + 3D object system: sprites, labels, particle systems, + terrain, mesh rendering, skeletal animation + libccscene.a - Scene graph: Scene, Node, Component, Director, Camera, + Renderer, Scheduler, Action system + libccphysics.a - Physics: Box2D JSB bindings, PhysX integration, + collision detection, rigid bodies, joints + libccaudio.a - Audio engine: decoders (MP3, OGG, WAV), mixer, player, + audio engine soft implementation + libccplatform.a - Platform abstraction: Android/iOS/Linux/Mac/Windows/Harmony + backends, input, system window, device info + libccapp.a - Application lifecycle: CocosApplication, BaseGame, Engine, + main entry, platform-specific app delegates + libccmisc.a - Everything else: UI widgets, network, editor-support + (spine/dragonbones runtime), profiler, plugins, storage, + GI/light-probe, primitive types, base utilities + +LINK ORDER (topological) + ccmath -> ccgeometry -> cclog -> ccunzip -> ccfilesystem + -> ccbindings -> ccutils -> ccrenderer -> cc2d3d -> ccscene + -> ccphysics -> ccaudio -> ccplatform -> ccapp -> ccmisc + +BUILD TIME + Total: ~260MB across all split .a files + Split: each module is 1-157MB depending on subsystem + +WHEN TO REBUILD A SINGLE MODULE + renderer/ change -> cmake --build . --target ccrenderer -j$(nproc) + audio/ change -> cmake --build . --target ccaudio -j$(nproc) + platform/ change -> cmake --build . --target ccplatform -j$(nproc) + +================================================== diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_2d_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_2d_auto.cpp new file mode 100644 index 0000000000..7e63eebcaa --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_2d_auto.cpp @@ -0,0 +1,3618 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_2d_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_assets_auto.h" + + +#define cc_UIMeshBuffer_vData_get(self_) self_->getVData() +#define cc_UIMeshBuffer_vData_set(self_, val_) self_->setVData(val_) + + +#define cc_UIMeshBuffer_iData_get(self_) self_->getIData() +#define cc_UIMeshBuffer_iData_set(self_, val_) self_->setIData(val_) + + +#define cc_RenderDrawInfo_bufferId_get(self_) self_->getBufferId() +#define cc_RenderDrawInfo_bufferId_set(self_, val_) self_->setBufferId(val_) + + +#define cc_RenderDrawInfo_accId_get(self_) self_->getAccId() +#define cc_RenderDrawInfo_accId_set(self_, val_) self_->setAccId(val_) + + +#define cc_RenderDrawInfo_vertexOffset_get(self_) self_->getVertexOffset() +#define cc_RenderDrawInfo_vertexOffset_set(self_, val_) self_->setVertexOffset(val_) + + +#define cc_RenderDrawInfo_indexOffset_get(self_) self_->getIndexOffset() +#define cc_RenderDrawInfo_indexOffset_set(self_, val_) self_->setIndexOffset(val_) + + +#define cc_RenderDrawInfo_vbCount_get(self_) self_->getVbCount() +#define cc_RenderDrawInfo_vbCount_set(self_, val_) self_->setVbCount(val_) + + +#define cc_RenderDrawInfo_ibCount_get(self_) self_->getIbCount() +#define cc_RenderDrawInfo_ibCount_set(self_, val_) self_->setIbCount(val_) + + +#define cc_RenderDrawInfo_vertDirty_get(self_) self_->getVertDirty() +#define cc_RenderDrawInfo_vertDirty_set(self_, val_) self_->setVertDirty(val_) + + +#define cc_RenderDrawInfo_dataHash_get(self_) self_->getDataHash() +#define cc_RenderDrawInfo_dataHash_set(self_, val_) self_->setDataHash(val_) + + +#define cc_RenderDrawInfo_isMeshBuffer_get(self_) self_->getIsMeshBuffer() +#define cc_RenderDrawInfo_isMeshBuffer_set(self_, val_) self_->setIsMeshBuffer(val_) + + +#define cc_RenderDrawInfo_vbBuffer_get(self_) self_->getVbBuffer() +#define cc_RenderDrawInfo_vbBuffer_set(self_, val_) self_->setVbBuffer(val_) + + +#define cc_RenderDrawInfo_ibBuffer_get(self_) self_->getIbBuffer() +#define cc_RenderDrawInfo_ibBuffer_set(self_, val_) self_->setIbBuffer(val_) + + +#define cc_RenderDrawInfo_vDataBuffer_get(self_) self_->getVDataBuffer() +#define cc_RenderDrawInfo_vDataBuffer_set(self_, val_) self_->setVDataBuffer(val_) + + +#define cc_RenderDrawInfo_iDataBuffer_get(self_) self_->getIDataBuffer() +#define cc_RenderDrawInfo_iDataBuffer_set(self_, val_) self_->setIDataBuffer(val_) + + +#define cc_RenderDrawInfo_material_get(self_) self_->getMaterial() +#define cc_RenderDrawInfo_material_set(self_, val_) self_->setMaterial(val_) + + +#define cc_RenderDrawInfo_texture_get(self_) self_->getTexture() +#define cc_RenderDrawInfo_texture_set(self_, val_) self_->setTexture(val_) + + +#define cc_RenderDrawInfo_sampler_get(self_) self_->getSampler() +#define cc_RenderDrawInfo_sampler_set(self_, val_) self_->setSampler(val_) + + +#define cc_RenderDrawInfo_model_get(self_) self_->getModel() +#define cc_RenderDrawInfo_model_set(self_, val_) self_->setModel(val_) + + +#define cc_RenderDrawInfo_drawInfoType_get(self_) self_->getDrawInfoType() +#define cc_RenderDrawInfo_drawInfoType_set(self_, val_) self_->setDrawInfoType(val_) + + +#define cc_RenderDrawInfo_subNode_get(self_) self_->getSubNode() +#define cc_RenderDrawInfo_subNode_set(self_, val_) self_->setSubNode(val_) + + +#define cc_RenderDrawInfo_stride_get(self_) self_->getStride() +#define cc_RenderDrawInfo_stride_set(self_, val_) self_->setStride(val_) + + +#define cc_RenderEntity_node_get(self_) self_->getNode() +#define cc_RenderEntity_node_set(self_, val_) self_->setNode(val_) + + +#define cc_RenderEntity_renderTransform_get(self_) self_->getRenderTransform() +#define cc_RenderEntity_renderTransform_set(self_, val_) self_->setRenderTransform(val_) + + +#define cc_RenderEntity_staticDrawInfoSize_get(self_) self_->getStaticDrawInfoSize() +#define cc_RenderEntity_staticDrawInfoSize_set(self_, val_) self_->setStaticDrawInfoSize(val_) + + +#define cc_RenderEntity_stencilStage_get(self_) self_->getStencilStage() +#define cc_RenderEntity_stencilStage_set(self_, val_) self_->setStencilStage(val_) + + + +se::Class* __jsb_cc_MeshBufferLayout_class = nullptr; +se::Object* __jsb_cc_MeshBufferLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MeshBufferLayout) + +static bool js_cc_MeshBufferLayout_byteOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->byteOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_byteOffset_set) + +static bool js_cc_MeshBufferLayout_byteOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->byteOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_byteOffset_get) + +static bool js_cc_MeshBufferLayout_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_vertexOffset_set) + +static bool js_cc_MeshBufferLayout_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_vertexOffset_get) + +static bool js_cc_MeshBufferLayout_indexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_indexOffset_set) + +static bool js_cc_MeshBufferLayout_indexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_indexOffset_get) + +static bool js_cc_MeshBufferLayout_dirtyMark_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dirtyMark, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_dirtyMark_set) + +static bool js_cc_MeshBufferLayout_dirtyMark_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dirtyMark, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_dirtyMark_get) + +static bool js_new_cc_MeshBufferLayout(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MeshBufferLayout *result; + result = (cc::MeshBufferLayout *)new cc::MeshBufferLayout(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MeshBufferLayout, __jsb_cc_MeshBufferLayout_class, js_delete_cc_MeshBufferLayout) + +static bool js_delete_cc_MeshBufferLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MeshBufferLayout) + +template<> +bool sevalue_to_native(const se::Value &from, cc::MeshBufferLayout * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("byteOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->byteOffset), ctx); + } + + + json->getProperty("vertexOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexOffset), ctx); + } + + + json->getProperty("indexOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexOffset), ctx); + } + + + json->getProperty("dirtyMark", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dirtyMark), ctx); + } + + + return ok; +} + + +bool js_register_cc_MeshBufferLayout(se::Object* obj) { + auto* cls = se::Class::create("MeshBufferLayout", obj, nullptr, _SE(js_new_cc_MeshBufferLayout)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("byteOffset", _SE(js_cc_MeshBufferLayout_byteOffset_get), _SE(js_cc_MeshBufferLayout_byteOffset_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_MeshBufferLayout_vertexOffset_get), _SE(js_cc_MeshBufferLayout_vertexOffset_set)); + cls->defineProperty("indexOffset", _SE(js_cc_MeshBufferLayout_indexOffset_get), _SE(js_cc_MeshBufferLayout_indexOffset_set)); + cls->defineProperty("dirtyMark", _SE(js_cc_MeshBufferLayout_dirtyMark_get), _SE(js_cc_MeshBufferLayout_dirtyMark_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MeshBufferLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MeshBufferLayout_proto = cls->getProto(); + __jsb_cc_MeshBufferLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_UIMeshBuffer_class = nullptr; +se::Object* __jsb_cc_UIMeshBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_UIMeshBuffer) + +static bool js_new_cc_UIMeshBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::UIMeshBuffer *result; + result = (cc::UIMeshBuffer *)new cc::UIMeshBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_UIMeshBuffer, __jsb_cc_UIMeshBuffer_class, js_delete_cc_UIMeshBuffer) + +static bool js_delete_cc_UIMeshBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_UIMeshBuffer) + +static bool js_cc_UIMeshBuffer_initialize__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + ccstd::vector< cc::gfx::Attribute > *arg2 = 0 ; + bool arg3 ; + ccstd::vector< cc::gfx::Attribute > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((ccstd::vector< cc::gfx::Attribute > &&)*arg2,arg3); + + + return true; +} + +static bool js_cc_UIMeshBuffer_initialize__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + ccstd::vector< cc::gfx::Attribute > *arg2 = 0 ; + ccstd::vector< cc::gfx::Attribute > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((ccstd::vector< cc::gfx::Attribute > &&)*arg2); + + + return true; +} + +static bool js_cc_UIMeshBuffer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_UIMeshBuffer_initialize__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_UIMeshBuffer_initialize__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_initialize) + +static bool js_cc_UIMeshBuffer_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_reset) + +static bool js_cc_UIMeshBuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_destroy) + +static bool js_cc_UIMeshBuffer_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_uploadBuffers) + +static bool js_cc_UIMeshBuffer_syncSharedBufferToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + uint32_t *arg2 = (uint32_t *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->syncSharedBufferToNative(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_syncSharedBufferToNative) + +static bool js_cc_UIMeshBuffer_vData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + float *arg2 = (float *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_UIMeshBuffer_vData_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_UIMeshBuffer_vData_set) + +static bool js_cc_UIMeshBuffer_vData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + float *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float *)cc_UIMeshBuffer_vData_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_UIMeshBuffer_vData_get) + +static bool js_cc_UIMeshBuffer_iData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + uint16_t *arg2 = (uint16_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_UIMeshBuffer_iData_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_UIMeshBuffer_iData_set) + +static bool js_cc_UIMeshBuffer_iData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + uint16_t *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (uint16_t *)cc_UIMeshBuffer_iData_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_UIMeshBuffer_iData_get) + +bool js_register_cc_UIMeshBuffer(se::Object* obj) { + auto* cls = se::Class::create("UIMeshBuffer", obj, nullptr, _SE(js_new_cc_UIMeshBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vData", _SE(js_cc_UIMeshBuffer_vData_get), _SE(js_cc_UIMeshBuffer_vData_set)); + cls->defineProperty("iData", _SE(js_cc_UIMeshBuffer_iData_get), _SE(js_cc_UIMeshBuffer_iData_set)); + + cls->defineFunction("initialize", _SE(js_cc_UIMeshBuffer_initialize)); + cls->defineFunction("reset", _SE(js_cc_UIMeshBuffer_reset)); + cls->defineFunction("destroy", _SE(js_cc_UIMeshBuffer_destroy)); + cls->defineFunction("uploadBuffers", _SE(js_cc_UIMeshBuffer_uploadBuffers)); + cls->defineFunction("syncSharedBufferToNative", _SE(js_cc_UIMeshBuffer_syncSharedBufferToNative)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_UIMeshBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_UIMeshBuffer_proto = cls->getProto(); + __jsb_cc_UIMeshBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Render2dLayout_class = nullptr; +se::Object* __jsb_cc_Render2dLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Render2dLayout) + +static bool js_cc_Render2dLayout_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Render2dLayout_position_set) + +static bool js_cc_Render2dLayout_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Render2dLayout_position_get) + +static bool js_cc_Render2dLayout_uv_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uv, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Render2dLayout_uv_set) + +static bool js_cc_Render2dLayout_uv_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uv, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uv, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Render2dLayout_uv_get) + +static bool js_cc_Render2dLayout_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Render2dLayout_color_set) + +static bool js_cc_Render2dLayout_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Render2dLayout_color_get) + +static bool js_new_cc_Render2dLayout(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Render2dLayout *result; + result = (cc::Render2dLayout *)new cc::Render2dLayout(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Render2dLayout, __jsb_cc_Render2dLayout_class, js_delete_cc_Render2dLayout) + +static bool js_delete_cc_Render2dLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Render2dLayout) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Render2dLayout * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("position", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->position), ctx); + } + + + json->getProperty("uv", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uv), ctx); + } + + + json->getProperty("color", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->color), ctx); + } + + + return ok; +} + + +bool js_register_cc_Render2dLayout(se::Object* obj) { + auto* cls = se::Class::create("Render2dLayout", obj, nullptr, _SE(js_new_cc_Render2dLayout)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_Render2dLayout_position_get), _SE(js_cc_Render2dLayout_position_set)); + cls->defineProperty("uv", _SE(js_cc_Render2dLayout_uv_get), _SE(js_cc_Render2dLayout_uv_set)); + cls->defineProperty("color", _SE(js_cc_Render2dLayout_color_get), _SE(js_cc_Render2dLayout_color_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Render2dLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Render2dLayout_proto = cls->getProto(); + __jsb_cc_Render2dLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_LocalDSBF_class = nullptr; +se::Object* __jsb_cc_LocalDSBF_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_LocalDSBF) + +static bool js_cc_LocalDSBF_ds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_LocalDSBF_ds_set) + +static bool js_cc_LocalDSBF_ds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ds, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ds, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_LocalDSBF_ds_get) + +static bool js_cc_LocalDSBF_uboBuf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uboBuf, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_LocalDSBF_uboBuf_set) + +static bool js_cc_LocalDSBF_uboBuf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uboBuf, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uboBuf, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_LocalDSBF_uboBuf_get) + +static bool js_new_cc_LocalDSBF(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::LocalDSBF *result; + result = (cc::LocalDSBF *)new cc::LocalDSBF(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_LocalDSBF, __jsb_cc_LocalDSBF_class, js_delete_cc_LocalDSBF) + +static bool js_delete_cc_LocalDSBF(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_LocalDSBF) + +template<> +bool sevalue_to_native(const se::Value &from, cc::LocalDSBF * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("ds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ds), ctx); + } + + + json->getProperty("uboBuf", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uboBuf), ctx); + } + + + return ok; +} + + +bool js_register_cc_LocalDSBF(se::Object* obj) { + auto* cls = se::Class::create("LocalDSBF", obj, nullptr, _SE(js_new_cc_LocalDSBF)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("ds", _SE(js_cc_LocalDSBF_ds_get), _SE(js_cc_LocalDSBF_ds_set)); + cls->defineProperty("uboBuf", _SE(js_cc_LocalDSBF_uboBuf_get), _SE(js_cc_LocalDSBF_uboBuf_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_LocalDSBF)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_LocalDSBF_proto = cls->getProto(); + __jsb_cc_LocalDSBF_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderDrawInfo_class = nullptr; +se::Object* __jsb_cc_RenderDrawInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderDrawInfo) + +static bool js_new_cc_RenderDrawInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RenderDrawInfo *result; + result = (cc::RenderDrawInfo *)new cc::RenderDrawInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RenderDrawInfo, __jsb_cc_RenderDrawInfo_class, js_delete_cc_RenderDrawInfo) + +static bool js_delete_cc_RenderDrawInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderDrawInfo) + +static bool js_cc_RenderDrawInfo_isVertexPositionInWorld(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderDrawInfo const *)arg1)->isVertexPositionInWorld(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_isVertexPositionInWorld) + +static bool js_cc_RenderDrawInfo_setMeshBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::UIMeshBuffer *arg2 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMeshBuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_setMeshBuffer) + +static bool js_cc_RenderDrawInfo_getMeshBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::UIMeshBuffer *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(s); + if (nullptr == arg1) return true; + result = (cc::UIMeshBuffer *)((cc::RenderDrawInfo const *)arg1)->getMeshBuffer(); + + 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_RenderDrawInfo_getMeshBuffer) + +static bool js_cc_RenderDrawInfo_changeMeshBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->changeMeshBuffer(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_changeMeshBuffer) + +static bool js_cc_RenderDrawInfo_setRender2dBufferToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRender2dBufferToNative(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_setRender2dBufferToNative) + +static bool js_cc_RenderDrawInfo_getAttrSharedBufferForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + se::Object *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(s); + if (nullptr == arg1) return true; + result = (se::Object *)((cc::RenderDrawInfo const *)arg1)->getAttrSharedBufferForJS(); + + 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_RenderDrawInfo_getAttrSharedBufferForJS) + +static bool js_cc_RenderDrawInfo_requestIA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::gfx::InputAssembler *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::InputAssembler *)(arg1)->requestIA(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_RenderDrawInfo_requestIA) + +static bool js_cc_RenderDrawInfo_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_uploadBuffers) + +static bool js_cc_RenderDrawInfo_resetMeshIA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetMeshIA(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_resetMeshIA) + +static bool js_cc_RenderDrawInfo_getLocalDes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)(arg1)->getLocalDes(); + + 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_RenderDrawInfo_getLocalDes) + +static bool js_cc_RenderDrawInfo_updateLocalDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + cc::gfx::DescriptorSetLayout *arg3 = (cc::gfx::DescriptorSetLayout *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLocalDescriptorSet(arg2,(cc::gfx::DescriptorSetLayout const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_updateLocalDescriptorSet) + +static bool js_cc_RenderDrawInfo_bufferId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_bufferId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_bufferId_set) + +static bool js_cc_RenderDrawInfo_bufferId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_bufferId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_bufferId_get) + +static bool js_cc_RenderDrawInfo_accId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_accId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_accId_set) + +static bool js_cc_RenderDrawInfo_accId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_accId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_accId_get) + +static bool js_cc_RenderDrawInfo_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_vertexOffset_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vertexOffset_set) + +static bool js_cc_RenderDrawInfo_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_vertexOffset_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_vertexOffset_get) + +static bool js_cc_RenderDrawInfo_indexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_indexOffset_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_indexOffset_set) + +static bool js_cc_RenderDrawInfo_indexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_indexOffset_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_indexOffset_get) + +static bool js_cc_RenderDrawInfo_vbCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_vbCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vbCount_set) + +static bool js_cc_RenderDrawInfo_vbCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_vbCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_vbCount_get) + +static bool js_cc_RenderDrawInfo_ibCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_ibCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_ibCount_set) + +static bool js_cc_RenderDrawInfo_ibCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_ibCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_ibCount_get) + +static bool js_cc_RenderDrawInfo_vertDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_vertDirty_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vertDirty_set) + +static bool js_cc_RenderDrawInfo_vertDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_RenderDrawInfo_vertDirty_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_vertDirty_get) + +static bool js_cc_RenderDrawInfo_dataHash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_dataHash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_dataHash_set) + +static bool js_cc_RenderDrawInfo_dataHash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_dataHash_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_RenderDrawInfo_dataHash_get) + +static bool js_cc_RenderDrawInfo_isMeshBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_isMeshBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_isMeshBuffer_set) + +static bool js_cc_RenderDrawInfo_isMeshBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_RenderDrawInfo_isMeshBuffer_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_isMeshBuffer_get) + +static bool js_cc_RenderDrawInfo_vbBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *arg2 = (float *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_vbBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vbBuffer_set) + +static bool js_cc_RenderDrawInfo_vbBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float *)cc_RenderDrawInfo_vbBuffer_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_RenderDrawInfo_vbBuffer_get) + +static bool js_cc_RenderDrawInfo_ibBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *arg2 = (uint16_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_ibBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_ibBuffer_set) + +static bool js_cc_RenderDrawInfo_ibBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (uint16_t *)cc_RenderDrawInfo_ibBuffer_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_RenderDrawInfo_ibBuffer_get) + +static bool js_cc_RenderDrawInfo_vDataBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *arg2 = (float *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_vDataBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vDataBuffer_set) + +static bool js_cc_RenderDrawInfo_vDataBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float *)cc_RenderDrawInfo_vDataBuffer_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_RenderDrawInfo_vDataBuffer_get) + +static bool js_cc_RenderDrawInfo_iDataBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *arg2 = (uint16_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_iDataBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_iDataBuffer_set) + +static bool js_cc_RenderDrawInfo_iDataBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (uint16_t *)cc_RenderDrawInfo_iDataBuffer_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_RenderDrawInfo_iDataBuffer_get) + +static bool js_cc_RenderDrawInfo_material_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_material_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_material_set) + +static bool js_cc_RenderDrawInfo_material_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_RenderDrawInfo_material_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_RenderDrawInfo_material_get) + +static bool js_cc_RenderDrawInfo_texture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_texture_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_texture_set) + +static bool js_cc_RenderDrawInfo_texture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_RenderDrawInfo_texture_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_RenderDrawInfo_texture_get) + +static bool js_cc_RenderDrawInfo_sampler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Sampler *arg2 = (cc::gfx::Sampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_sampler_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_sampler_set) + +static bool js_cc_RenderDrawInfo_sampler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Sampler *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)cc_RenderDrawInfo_sampler_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_RenderDrawInfo_sampler_get) + +static bool js_cc_RenderDrawInfo_model_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_model_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_model_set) + +static bool js_cc_RenderDrawInfo_model_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_RenderDrawInfo_model_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_RenderDrawInfo_model_get) + +static bool js_cc_RenderDrawInfo_drawInfoType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_drawInfoType_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_drawInfoType_set) + +static bool js_cc_RenderDrawInfo_drawInfoType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_drawInfoType_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_drawInfoType_get) + +static bool js_cc_RenderDrawInfo_subNode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_subNode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_subNode_set) + +static bool js_cc_RenderDrawInfo_subNode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_RenderDrawInfo_subNode_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_RenderDrawInfo_subNode_get) + +static bool js_cc_RenderDrawInfo_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint8_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_stride_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_stride_set) + +static bool js_cc_RenderDrawInfo_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint8_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_stride_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_stride_get) + +bool js_register_cc_RenderDrawInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderDrawInfo", obj, nullptr, _SE(js_new_cc_RenderDrawInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bufferId", _SE(js_cc_RenderDrawInfo_bufferId_get), _SE(js_cc_RenderDrawInfo_bufferId_set)); + cls->defineProperty("accId", _SE(js_cc_RenderDrawInfo_accId_get), _SE(js_cc_RenderDrawInfo_accId_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_RenderDrawInfo_vertexOffset_get), _SE(js_cc_RenderDrawInfo_vertexOffset_set)); + cls->defineProperty("indexOffset", _SE(js_cc_RenderDrawInfo_indexOffset_get), _SE(js_cc_RenderDrawInfo_indexOffset_set)); + cls->defineProperty("vbCount", _SE(js_cc_RenderDrawInfo_vbCount_get), _SE(js_cc_RenderDrawInfo_vbCount_set)); + cls->defineProperty("ibCount", _SE(js_cc_RenderDrawInfo_ibCount_get), _SE(js_cc_RenderDrawInfo_ibCount_set)); + cls->defineProperty("vertDirty", _SE(js_cc_RenderDrawInfo_vertDirty_get), _SE(js_cc_RenderDrawInfo_vertDirty_set)); + cls->defineProperty("dataHash", _SE(js_cc_RenderDrawInfo_dataHash_get), _SE(js_cc_RenderDrawInfo_dataHash_set)); + cls->defineProperty("isMeshBuffer", _SE(js_cc_RenderDrawInfo_isMeshBuffer_get), _SE(js_cc_RenderDrawInfo_isMeshBuffer_set)); + cls->defineProperty("vbBuffer", _SE(js_cc_RenderDrawInfo_vbBuffer_get), _SE(js_cc_RenderDrawInfo_vbBuffer_set)); + cls->defineProperty("ibBuffer", _SE(js_cc_RenderDrawInfo_ibBuffer_get), _SE(js_cc_RenderDrawInfo_ibBuffer_set)); + cls->defineProperty("vDataBuffer", _SE(js_cc_RenderDrawInfo_vDataBuffer_get), _SE(js_cc_RenderDrawInfo_vDataBuffer_set)); + cls->defineProperty("iDataBuffer", _SE(js_cc_RenderDrawInfo_iDataBuffer_get), _SE(js_cc_RenderDrawInfo_iDataBuffer_set)); + cls->defineProperty("material", _SE(js_cc_RenderDrawInfo_material_get), _SE(js_cc_RenderDrawInfo_material_set)); + cls->defineProperty("texture", _SE(js_cc_RenderDrawInfo_texture_get), _SE(js_cc_RenderDrawInfo_texture_set)); + cls->defineProperty("sampler", _SE(js_cc_RenderDrawInfo_sampler_get), _SE(js_cc_RenderDrawInfo_sampler_set)); + cls->defineProperty("model", _SE(js_cc_RenderDrawInfo_model_get), _SE(js_cc_RenderDrawInfo_model_set)); + cls->defineProperty("drawInfoType", _SE(js_cc_RenderDrawInfo_drawInfoType_get), _SE(js_cc_RenderDrawInfo_drawInfoType_set)); + cls->defineProperty("subNode", _SE(js_cc_RenderDrawInfo_subNode_get), _SE(js_cc_RenderDrawInfo_subNode_set)); + cls->defineProperty("stride", _SE(js_cc_RenderDrawInfo_stride_get), _SE(js_cc_RenderDrawInfo_stride_set)); + + cls->defineFunction("isVertexPositionInWorld", _SE(js_cc_RenderDrawInfo_isVertexPositionInWorld)); + cls->defineFunction("setMeshBuffer", _SE(js_cc_RenderDrawInfo_setMeshBuffer)); + cls->defineFunction("getMeshBuffer", _SE(js_cc_RenderDrawInfo_getMeshBuffer)); + cls->defineFunction("changeMeshBuffer", _SE(js_cc_RenderDrawInfo_changeMeshBuffer)); + cls->defineFunction("setRender2dBufferToNative", _SE(js_cc_RenderDrawInfo_setRender2dBufferToNative)); + cls->defineFunction("getAttrSharedBufferForJS", _SE(js_cc_RenderDrawInfo_getAttrSharedBufferForJS)); + cls->defineFunction("requestIA", _SE(js_cc_RenderDrawInfo_requestIA)); + cls->defineFunction("uploadBuffers", _SE(js_cc_RenderDrawInfo_uploadBuffers)); + cls->defineFunction("resetMeshIA", _SE(js_cc_RenderDrawInfo_resetMeshIA)); + cls->defineFunction("getLocalDes", _SE(js_cc_RenderDrawInfo_getLocalDes)); + cls->defineFunction("updateLocalDescriptorSet", _SE(js_cc_RenderDrawInfo_updateLocalDescriptorSet)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderDrawInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderDrawInfo_proto = cls->getProto(); + __jsb_cc_RenderDrawInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderEntity_class = nullptr; +se::Object* __jsb_cc_RenderEntity_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderEntity) + +static bool js_new_cc_RenderEntity(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::RenderEntityType arg1 ; + cc::RenderEntity *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderEntity *)new cc::RenderEntity(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RenderEntity, __jsb_cc_RenderEntity_class, js_delete_cc_RenderEntity) + +static bool js_delete_cc_RenderEntity(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderEntity) + +static bool js_cc_RenderEntity_addDynamicRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::RenderDrawInfo *arg2 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDynamicRenderDrawInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_addDynamicRenderDrawInfo) + +static bool js_cc_RenderEntity_setDynamicRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::RenderDrawInfo *arg2 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDynamicRenderDrawInfo(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_setDynamicRenderDrawInfo) + +static bool js_cc_RenderEntity_removeDynamicRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeDynamicRenderDrawInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_removeDynamicRenderDrawInfo) + +static bool js_cc_RenderEntity_clearDynamicRenderDrawInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearDynamicRenderDrawInfos(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_clearDynamicRenderDrawInfos) + +static bool js_cc_RenderEntity_clearStaticRenderDrawInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearStaticRenderDrawInfos(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_clearStaticRenderDrawInfos) + +static bool js_cc_RenderEntity_getIsMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getIsMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getIsMask) + +static bool js_cc_RenderEntity_getIsSubMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getIsSubMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getIsSubMask) + +static bool js_cc_RenderEntity_getIsMaskInverted(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getIsMaskInverted(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getIsMaskInverted) + +static bool js_cc_RenderEntity_getUseLocal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getUseLocal(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getUseLocal) + +static bool js_cc_RenderEntity_setUseLocal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUseLocal(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_setUseLocal) + +static bool js_cc_RenderEntity_getFillColorType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::FillColorType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::FillColorType)((cc::RenderEntity const *)arg1)->getFillColorType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getFillColorType) + +static bool js_cc_RenderEntity_getStaticRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + cc::RenderDrawInfo *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderDrawInfo *)(arg1)->getStaticRenderDrawInfo(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_RenderEntity_getStaticRenderDrawInfo) + +static bool js_cc_RenderEntity_getStaticRenderDrawInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + std::array< cc::RenderDrawInfo,4 > *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(s); + if (nullptr == arg1) return true; + result = (std::array< cc::RenderDrawInfo,4 > *) &(arg1)->getStaticRenderDrawInfos(); + + 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_RenderEntity_getStaticRenderDrawInfos) + +static bool js_cc_RenderEntity_getEntitySharedBufferForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + se::Object *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(s); + if (nullptr == arg1) return true; + result = (se::Object *)((cc::RenderEntity const *)arg1)->getEntitySharedBufferForJS(); + + 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_RenderEntity_getEntitySharedBufferForJS) + +static bool js_cc_RenderEntity_getColorAlpha(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::RenderEntity const *)arg1)->getColorAlpha(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getColorAlpha) + +static bool js_cc_RenderEntity_getOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::RenderEntity const *)arg1)->getOpacity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getOpacity) + +static bool js_cc_RenderEntity_setOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_setOpacity) + +static bool js_cc_RenderEntity_getRenderDrawInfosSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::RenderEntity const *)arg1)->getRenderDrawInfosSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getRenderDrawInfosSize) + +static bool js_cc_RenderEntity_getRenderDrawInfoAt(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + cc::RenderDrawInfo *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderDrawInfo *)(arg1)->getRenderDrawInfoAt(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_RenderEntity_getRenderDrawInfoAt) + +static bool js_cc_RenderEntity_getPriority(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::RenderEntity const *)arg1)->getPriority(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getPriority) + +static bool js_cc_RenderEntity_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderEntity_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_node_set) + +static bool js_cc_RenderEntity_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_RenderEntity_node_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_RenderEntity_node_get) + +static bool js_cc_RenderEntity_renderTransform_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderEntity_renderTransform_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_renderTransform_set) + +static bool js_cc_RenderEntity_renderTransform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_RenderEntity_renderTransform_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_RenderEntity_renderTransform_get) + +static bool js_cc_RenderEntity_staticDrawInfoSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderEntity_staticDrawInfoSize_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_staticDrawInfoSize_set) + +static bool js_cc_RenderEntity_staticDrawInfoSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderEntity_staticDrawInfoSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderEntity_staticDrawInfoSize_get) + +static bool js_cc_RenderEntity_stencilStage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderEntity_stencilStage_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_stencilStage_set) + +static bool js_cc_RenderEntity_stencilStage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderEntity_stencilStage_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderEntity_stencilStage_get) + +bool js_register_cc_RenderEntity(se::Object* obj) { + auto* cls = se::Class::create("RenderEntity", obj, nullptr, _SE(js_new_cc_RenderEntity)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("node", _SE(js_cc_RenderEntity_node_get), _SE(js_cc_RenderEntity_node_set)); + cls->defineProperty("renderTransform", _SE(js_cc_RenderEntity_renderTransform_get), _SE(js_cc_RenderEntity_renderTransform_set)); + cls->defineProperty("staticDrawInfoSize", _SE(js_cc_RenderEntity_staticDrawInfoSize_get), _SE(js_cc_RenderEntity_staticDrawInfoSize_set)); + cls->defineProperty("stencilStage", _SE(js_cc_RenderEntity_stencilStage_get), _SE(js_cc_RenderEntity_stencilStage_set)); + + cls->defineFunction("addDynamicRenderDrawInfo", _SE(js_cc_RenderEntity_addDynamicRenderDrawInfo)); + cls->defineFunction("setDynamicRenderDrawInfo", _SE(js_cc_RenderEntity_setDynamicRenderDrawInfo)); + cls->defineFunction("removeDynamicRenderDrawInfo", _SE(js_cc_RenderEntity_removeDynamicRenderDrawInfo)); + cls->defineFunction("clearDynamicRenderDrawInfos", _SE(js_cc_RenderEntity_clearDynamicRenderDrawInfos)); + cls->defineFunction("clearStaticRenderDrawInfos", _SE(js_cc_RenderEntity_clearStaticRenderDrawInfos)); + cls->defineFunction("getIsMask", _SE(js_cc_RenderEntity_getIsMask)); + cls->defineFunction("getIsSubMask", _SE(js_cc_RenderEntity_getIsSubMask)); + cls->defineFunction("getIsMaskInverted", _SE(js_cc_RenderEntity_getIsMaskInverted)); + cls->defineFunction("getUseLocal", _SE(js_cc_RenderEntity_getUseLocal)); + cls->defineFunction("setUseLocal", _SE(js_cc_RenderEntity_setUseLocal)); + cls->defineFunction("getFillColorType", _SE(js_cc_RenderEntity_getFillColorType)); + cls->defineFunction("getStaticRenderDrawInfo", _SE(js_cc_RenderEntity_getStaticRenderDrawInfo)); + cls->defineFunction("getStaticRenderDrawInfos", _SE(js_cc_RenderEntity_getStaticRenderDrawInfos)); + cls->defineFunction("getEntitySharedBufferForJS", _SE(js_cc_RenderEntity_getEntitySharedBufferForJS)); + cls->defineFunction("getColorAlpha", _SE(js_cc_RenderEntity_getColorAlpha)); + cls->defineFunction("getOpacity", _SE(js_cc_RenderEntity_getOpacity)); + cls->defineFunction("setOpacity", _SE(js_cc_RenderEntity_setOpacity)); + cls->defineFunction("getRenderDrawInfosSize", _SE(js_cc_RenderEntity_getRenderDrawInfosSize)); + cls->defineFunction("getRenderDrawInfoAt", _SE(js_cc_RenderEntity_getRenderDrawInfoAt)); + cls->defineFunction("getPriority", _SE(js_cc_RenderEntity_getPriority)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderEntity)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderEntity_proto = cls->getProto(); + __jsb_cc_RenderEntity_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_UIModelProxy_class = nullptr; +se::Object* __jsb_cc_UIModelProxy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_UIModelProxy) + +static bool js_new_cc_UIModelProxy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::UIModelProxy *result; + result = (cc::UIModelProxy *)new cc::UIModelProxy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_UIModelProxy, __jsb_cc_UIModelProxy_class, js_delete_cc_UIModelProxy) + +static bool js_delete_cc_UIModelProxy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_UIModelProxy) + +static bool js_cc_UIModelProxy_initModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_initModel) + +static bool js_cc_UIModelProxy_activeSubModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activeSubModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_activeSubModels) + +static bool js_cc_UIModelProxy_uploadData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadData(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_uploadData) + +static bool js_cc_UIModelProxy_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_destroy) + +static bool js_cc_UIModelProxy_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_clear) + +static bool js_cc_UIModelProxy_getModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::scene::Model *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)((cc::UIModelProxy const *)arg1)->getModel(); + + 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_UIModelProxy_getModel) + +static bool js_cc_UIModelProxy_updateModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateModels(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_updateModels) + +static bool js_cc_UIModelProxy_attachDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->attachDrawInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_attachDrawInfo) + +static bool js_cc_UIModelProxy_attachNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachNode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_attachNode) + +static bool js_cc_UIModelProxy_clearModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_clearModels) + +bool js_register_cc_UIModelProxy(se::Object* obj) { + auto* cls = se::Class::create("UIModelProxy", obj, nullptr, _SE(js_new_cc_UIModelProxy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initModel", _SE(js_cc_UIModelProxy_initModel)); + cls->defineFunction("activeSubModels", _SE(js_cc_UIModelProxy_activeSubModels)); + cls->defineFunction("uploadData", _SE(js_cc_UIModelProxy_uploadData)); + cls->defineFunction("destroy", _SE(js_cc_UIModelProxy_destroy)); + cls->defineFunction("clear", _SE(js_cc_UIModelProxy_clear)); + cls->defineFunction("getModel", _SE(js_cc_UIModelProxy_getModel)); + cls->defineFunction("updateModels", _SE(js_cc_UIModelProxy_updateModels)); + cls->defineFunction("attachDrawInfo", _SE(js_cc_UIModelProxy_attachDrawInfo)); + cls->defineFunction("attachNode", _SE(js_cc_UIModelProxy_attachNode)); + cls->defineFunction("clearModels", _SE(js_cc_UIModelProxy_clearModels)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_UIModelProxy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_UIModelProxy_proto = cls->getProto(); + __jsb_cc_UIModelProxy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RecordedRendererInfo_class = nullptr; +se::Object* __jsb_cc_RecordedRendererInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RecordedRendererInfo) + +static bool js_cc_RecordedRendererInfo_renderEntity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RecordedRendererInfo *arg1 = (cc::RecordedRendererInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderEntity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RecordedRendererInfo_renderEntity_set) + +static bool js_cc_RecordedRendererInfo_renderEntity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RecordedRendererInfo *arg1 = (cc::RecordedRendererInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderEntity, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderEntity, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RecordedRendererInfo_renderEntity_get) + +static bool js_new_cc_RecordedRendererInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RecordedRendererInfo *result; + result = (cc::RecordedRendererInfo *)new cc::RecordedRendererInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RecordedRendererInfo, __jsb_cc_RecordedRendererInfo_class, js_delete_cc_RecordedRendererInfo) + +static bool js_delete_cc_RecordedRendererInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RecordedRendererInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::RecordedRendererInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("renderEntity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderEntity), ctx); + } + + + return ok; +} + + +bool js_register_cc_RecordedRendererInfo(se::Object* obj) { + auto* cls = se::Class::create("RecordedRendererInfo", obj, nullptr, _SE(js_new_cc_RecordedRendererInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderEntity", _SE(js_cc_RecordedRendererInfo_renderEntity_get), _SE(js_cc_RecordedRendererInfo_renderEntity_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RecordedRendererInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RecordedRendererInfo_proto = cls->getProto(); + __jsb_cc_RecordedRendererInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Batcher2d_class = nullptr; +se::Object* __jsb_cc_Batcher2d_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Batcher2d) + +static bool js_cc_Batcher2d_setSorting2DCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int32_t arg1 ; + + 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::Batcher2d::setSorting2DCount(SWIG_STD_MOVE(arg1)); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_setSorting2DCount_static) + +static bool js_new_cc_Batcher2d__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Batcher2d *result; + result = (cc::Batcher2d *)new cc::Batcher2d(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Batcher2d__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::Batcher2d *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Batcher2d *)new cc::Batcher2d(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Batcher2d(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Batcher2d__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Batcher2d__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Batcher2d"); + return false; +} +SE_BIND_CTOR(js_new_cc_Batcher2d, __jsb_cc_Batcher2d_class, js_delete_cc_Batcher2d) + +static bool js_delete_cc_Batcher2d(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Batcher2d) + +static bool js_cc_Batcher2d_syncMeshBuffersToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + uint16_t arg2 ; + ccstd::vector< cc::UIMeshBuffer * > *arg3 = 0 ; + ccstd::vector< cc::UIMeshBuffer * > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->syncMeshBuffersToNative(arg2,(ccstd::vector< cc::UIMeshBuffer * > &&)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_syncMeshBuffersToNative) + +static bool js_cc_Batcher2d_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->initialize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_initialize) + +static bool js_cc_Batcher2d_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_update) + +static bool js_cc_Batcher2d_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_uploadBuffers) + +static bool js_cc_Batcher2d_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_reset) + +static bool js_cc_Batcher2d_syncRootNodesToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + ccstd::vector< cc::Node * > *arg2 = 0 ; + ccstd::vector< cc::Node * > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->syncRootNodesToNative((ccstd::vector< cc::Node * > &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_syncRootNodesToNative) + +static bool js_cc_Batcher2d_releaseDescriptorSetCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->releaseDescriptorSetCache(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_releaseDescriptorSetCache) + +static bool js_cc_Batcher2d_getDefaultAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + ccstd::vector< cc::gfx::Attribute > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gfx::Attribute > *)(arg1)->getDefaultAttribute(); + + 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_Batcher2d_getDefaultAttribute) + +static bool js_cc_Batcher2d_handlePostRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->handlePostRender(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_handlePostRender) + +bool js_register_cc_Batcher2d(se::Object* obj) { + auto* cls = se::Class::create("Batcher2d", obj, nullptr, _SE(js_new_cc_Batcher2d)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("syncMeshBuffersToNative", _SE(js_cc_Batcher2d_syncMeshBuffersToNative)); + cls->defineFunction("initialize", _SE(js_cc_Batcher2d_initialize)); + cls->defineFunction("update", _SE(js_cc_Batcher2d_update)); + cls->defineFunction("uploadBuffers", _SE(js_cc_Batcher2d_uploadBuffers)); + cls->defineFunction("reset", _SE(js_cc_Batcher2d_reset)); + cls->defineFunction("syncRootNodesToNative", _SE(js_cc_Batcher2d_syncRootNodesToNative)); + cls->defineFunction("releaseDescriptorSetCache", _SE(js_cc_Batcher2d_releaseDescriptorSetCache)); + cls->defineFunction("getDefaultAttribute", _SE(js_cc_Batcher2d_getDefaultAttribute)); + cls->defineFunction("handlePostRender", _SE(js_cc_Batcher2d_handlePostRender)); + + + cls->defineStaticFunction("setSorting2DCount", _SE(js_cc_Batcher2d_setSorting2DCount_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Batcher2d)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Batcher2d_proto = cls->getProto(); + __jsb_cc_Batcher2d_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_native2d(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("n2d", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("n2d", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_MeshBufferLayout(ns); + js_register_cc_UIMeshBuffer(ns); + js_register_cc_Render2dLayout(ns); + js_register_cc_LocalDSBF(ns); + js_register_cc_RenderDrawInfo(ns); + js_register_cc_RenderEntity(ns); + js_register_cc_UIModelProxy(ns); + js_register_cc_RecordedRendererInfo(ns); + js_register_cc_Batcher2d(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_2d_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_2d_auto.h new file mode 100644 index 0000000000..af4a44937b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_2d_auto.h @@ -0,0 +1,109 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "2d/renderer/RenderDrawInfo.h" +#include "2d/renderer/UIMeshBuffer.h" +#include "2d/renderer/Batcher2d.h" +#include "2d/renderer/RenderEntity.h" +#include "2d/renderer/UIModelProxy.h" + + + +bool register_all_native2d(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::MeshBufferLayout); +extern se::Object *__jsb_cc_MeshBufferLayout_proto; // NOLINT +extern se::Class * __jsb_cc_MeshBufferLayout_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::MeshBufferLayout * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::UIMeshBuffer); +extern se::Object *__jsb_cc_UIMeshBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_UIMeshBuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Render2dLayout); +extern se::Object *__jsb_cc_Render2dLayout_proto; // NOLINT +extern se::Class * __jsb_cc_Render2dLayout_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Render2dLayout * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::LocalDSBF); +extern se::Object *__jsb_cc_LocalDSBF_proto; // NOLINT +extern se::Class * __jsb_cc_LocalDSBF_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::LocalDSBF * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderDrawInfo); +extern se::Object *__jsb_cc_RenderDrawInfo_proto; // NOLINT +extern se::Class * __jsb_cc_RenderDrawInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderEntity); +extern se::Object *__jsb_cc_RenderEntity_proto; // NOLINT +extern se::Class * __jsb_cc_RenderEntity_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::UIModelProxy); +extern se::Object *__jsb_cc_UIModelProxy_proto; // NOLINT +extern se::Class * __jsb_cc_UIModelProxy_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::RecordedRendererInfo); +extern se::Object *__jsb_cc_RecordedRendererInfo_proto; // NOLINT +extern se::Class * __jsb_cc_RecordedRendererInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::RecordedRendererInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Batcher2d); +extern se::Object *__jsb_cc_Batcher2d_proto; // NOLINT +extern se::Class * __jsb_cc_Batcher2d_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_assets_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_assets_auto.cpp new file mode 100644 index 0000000000..7c6f500241 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_assets_auto.cpp @@ -0,0 +1,27993 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "renderer/core/PassUtils.h" +#include "renderer/gfx-base/GFXDef-common.h" +#include "renderer/pipeline/Define.h" +#include "renderer/pipeline/RenderStage.h" +#include "scene/Pass.h" +#include "scene/RenderWindow.h" +#include "core/scene-graph/Scene.h" + + +#define cc_Asset__uuid_get(self_) self_->getUuid() +#define cc_Asset__uuid_set(self_, val_) self_->setUuid(val_) + + +#define cc_Asset_uuid_get(self_) self_->getUuid() + + +#define cc_Asset_nativeUrl_get(self_) self_->getNativeUrl() + + +#define cc_Asset__nativeDep_get(self_) self_->getNativeDep() + + +#define cc_Asset_isDefault_get(self_) self_->isDefault() + + +#define cc_ImageAsset_format_get(self_) self_->getFormat() +#define cc_ImageAsset_format_set(self_, val_) self_->setFormat(val_) + + +#define cc_ImageAsset_url_get(self_) self_->getUrl() +#define cc_ImageAsset_url_set(self_, val_) self_->setUrl(val_) + + +#define cc_BufferAsset__nativeAsset_get(self_) self_->getNativeAssetForJS() +#define cc_BufferAsset__nativeAsset_set(self_, val_) self_->setNativeAssetForJS(val_) + + +#define cc_TextureBase_isCompressed_get(self_) self_->isCompressed() + + +#define cc_TextureBase_isAlphaAtlas_get(self_) self_->isAlphaAtlas() + + +#define cc_TextureBase__width_get(self_) self_->getWidth() +#define cc_TextureBase__width_set(self_, val_) self_->setWidth(val_) + + +#define cc_TextureBase_width_get(self_) self_->getWidth() +#define cc_TextureBase_width_set(self_, val_) self_->setWidth(val_) + + +#define cc_TextureBase__height_get(self_) self_->getHeight() +#define cc_TextureBase__height_set(self_, val_) self_->setHeight(val_) + + +#define cc_TextureBase_height_get(self_) self_->getHeight() +#define cc_TextureBase_height_set(self_, val_) self_->setHeight(val_) + + +#define cc_SimpleTexture_mipmapLevel_get(self_) self_->mipmapLevel() + + +#define cc_RenderTexture_window_get(self_) self_->getWindow() + + +#define cc_Mesh__hash_get(self_) self_->getHash() +#define cc_Mesh__hash_set(self_, val_) self_->setHash(val_) + + +#define cc_Mesh_hash_get(self_) self_->getHash() + + +#define cc_Mesh_data_get(self_) self_->getData() + + +#define cc_Mesh__data_get(self_) self_->getData() + + +#define cc_Mesh_jointBufferIndices_get(self_) self_->getJointBufferIndices() + + +#define cc_Mesh_renderingSubMeshes_get(self_) self_->getRenderingSubMeshes() + + +#define cc_Mesh_subMeshCount_get(self_) self_->getSubMeshCount() + + +#define cc_Mesh__nativeAsset_get(self_) self_->getAssetData() +#define cc_Mesh__nativeAsset_set(self_, val_) self_->setAssetData(val_) + + +#define cc_Mesh__allowDataAccess_get(self_) self_->isAllowDataAccess() +#define cc_Mesh__allowDataAccess_set(self_, val_) self_->setAllowDataAccess(val_) + + +#define cc_Mesh_allowDataAccess_get(self_) self_->isAllowDataAccess() +#define cc_Mesh_allowDataAccess_set(self_, val_) self_->setAllowDataAccess(val_) + + +#define cc_Material_effectAsset_get(self_) self_->getEffectAsset() +#define cc_Material_effectAsset_set(self_, val_) self_->setEffectAsset(val_) + + +#define cc_Material_effectName_get(self_) self_->getEffectName() + + +#define cc_Material_technique_get(self_) self_->getTechniqueIndex() + + +#define cc_Material_hash_get(self_) self_->getHash() + + +#define cc_Material_parent_get(self_) self_->getParent() + + +#define cc_RenderingSubMesh_mesh_get(self_) self_->getMesh() +#define cc_RenderingSubMesh_mesh_set(self_, val_) self_->setMesh(val_) + + +#define cc_RenderingSubMesh_subMeshIdx_get(self_) self_->getSubMeshIdx() +#define cc_RenderingSubMesh_subMeshIdx_set(self_, val_) self_->setSubMeshIdx(val_) + + +#define cc_RenderingSubMesh_flatBuffers_get(self_) self_->getFlatBuffers() +#define cc_RenderingSubMesh_flatBuffers_set(self_, val_) self_->setFlatBuffers(val_) + + +#define cc_RenderingSubMesh__flatBuffers_get(self_) self_->getFlatBuffers() +#define cc_RenderingSubMesh__flatBuffers_set(self_, val_) self_->setFlatBuffers(val_) + + +#define cc_RenderingSubMesh_jointMappedBuffers_get(self_) self_->getJointMappedBuffers() + + +#define cc_RenderingSubMesh_iaInfo_get(self_) self_->getIaInfo() + + +#define cc_RenderingSubMesh__iaInfo_get(self_) self_->getIaInfo() + + +#define cc_RenderingSubMesh_primitiveMode_get(self_) self_->getPrimitiveMode() + + +#define cc_Skeleton_joints_get(self_) self_->getJoints() +#define cc_Skeleton_joints_set(self_, val_) self_->setJoints(val_) + + +#define cc_Skeleton__joints_get(self_) self_->getJoints() +#define cc_Skeleton__joints_set(self_, val_) self_->setJoints(val_) + + +#define cc_Skeleton_hash_get(self_) self_->getHash() +#define cc_Skeleton_hash_set(self_, val_) self_->setHash(val_) + + +#define cc_Skeleton__hash_get(self_) self_->getHash() +#define cc_Skeleton__hash_set(self_, val_) self_->setHash(val_) + + +#define cc_Skeleton__invBindposes_get(self_) self_->getInverseBindposes() + + +#define cc_Skeleton_inverseBindposes_get(self_) self_->getInverseBindposes() + + +#define cc_EffectAsset_techniques_get(self_) self_->getTechniques() +#define cc_EffectAsset_techniques_set(self_, val_) self_->setTechniques(val_) + + +#define cc_EffectAsset_shaders_get(self_) self_->getShaders() +#define cc_EffectAsset_shaders_set(self_, val_) self_->setShaders(val_) + + +#define cc_EffectAsset_combinations_get(self_) self_->getCombinations() +#define cc_EffectAsset_combinations_set(self_, val_) self_->setCombinations(val_) + + + +se::Class* __jsb_cc_Error_class = nullptr; +se::Object* __jsb_cc_Error_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Error) + +static bool js_cc_Error_msg_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Error *arg1 = (cc::Error *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->msg, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Error_msg_set) + +static bool js_cc_Error_msg_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Error *arg1 = (cc::Error *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->msg, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->msg, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Error_msg_get) + +static bool js_new_cc_Error(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Error *result; + result = (cc::Error *)new cc::Error(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Error, __jsb_cc_Error_class, js_delete_cc_Error) + +static bool js_delete_cc_Error(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Error) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Error * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("msg", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->msg), ctx); + } + + + return ok; +} + + +bool js_register_cc_Error(se::Object* obj) { + auto* cls = se::Class::create("Error", obj, nullptr, _SE(js_new_cc_Error)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("msg", _SE(js_cc_Error_msg_get), _SE(js_cc_Error_msg_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Error)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Error_proto = cls->getProto(); + __jsb_cc_Error_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BoundingBox_class = nullptr; +se::Object* __jsb_cc_BoundingBox_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BoundingBox) + +static bool js_cc_BoundingBox_min_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->min, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BoundingBox_min_set) + +static bool js_cc_BoundingBox_min_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->min, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->min, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BoundingBox_min_get) + +static bool js_cc_BoundingBox_max_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->max, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BoundingBox_max_set) + +static bool js_cc_BoundingBox_max_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->max, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->max, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BoundingBox_max_get) + +static bool js_new_cc_BoundingBox(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BoundingBox *result; + result = (cc::BoundingBox *)new cc::BoundingBox(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BoundingBox, __jsb_cc_BoundingBox_class, js_delete_cc_BoundingBox) + +static bool js_delete_cc_BoundingBox(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BoundingBox) + +template<> +bool sevalue_to_native(const se::Value &from, cc::BoundingBox * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("min", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->min), ctx); + } + + + json->getProperty("max", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->max), ctx); + } + + + return ok; +} + + +bool js_register_cc_BoundingBox(se::Object* obj) { + auto* cls = se::Class::create("BoundingBox", obj, nullptr, _SE(js_new_cc_BoundingBox)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("min", _SE(js_cc_BoundingBox_min_get), _SE(js_cc_BoundingBox_min_set)); + cls->defineProperty("max", _SE(js_cc_BoundingBox_max_get), _SE(js_cc_BoundingBox_max_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BoundingBox)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BoundingBox_proto = cls->getProto(); + __jsb_cc_BoundingBox_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_VertexIdChannel_class = nullptr; +se::Object* __jsb_cc_VertexIdChannel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_VertexIdChannel) + +static bool js_cc_VertexIdChannel_stream_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stream, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_VertexIdChannel_stream_set) + +static bool js_cc_VertexIdChannel_stream_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stream, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_VertexIdChannel_stream_get) + +static bool js_cc_VertexIdChannel_index_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->index, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_VertexIdChannel_index_set) + +static bool js_cc_VertexIdChannel_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->index, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_VertexIdChannel_index_get) + +static bool js_new_cc_VertexIdChannel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::VertexIdChannel *result; + result = (cc::VertexIdChannel *)new cc::VertexIdChannel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_VertexIdChannel, __jsb_cc_VertexIdChannel_class, js_delete_cc_VertexIdChannel) + +static bool js_delete_cc_VertexIdChannel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_VertexIdChannel) + +template<> +bool sevalue_to_native(const se::Value &from, cc::VertexIdChannel * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("stream", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stream), ctx); + } + + + json->getProperty("index", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->index), ctx); + } + + + return ok; +} + + +bool js_register_cc_VertexIdChannel(se::Object* obj) { + auto* cls = se::Class::create("VertexIdChannel", obj, nullptr, _SE(js_new_cc_VertexIdChannel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("stream", _SE(js_cc_VertexIdChannel_stream_get), _SE(js_cc_VertexIdChannel_stream_set)); + cls->defineProperty("index", _SE(js_cc_VertexIdChannel_index_get), _SE(js_cc_VertexIdChannel_index_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_VertexIdChannel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_VertexIdChannel_proto = cls->getProto(); + __jsb_cc_VertexIdChannel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_NativeDep_class = nullptr; +se::Object* __jsb_cc_NativeDep_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_NativeDep) + +static bool js_cc_NativeDep_uuid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uuid, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_NativeDep_uuid_set) + +static bool js_cc_NativeDep_uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uuid, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uuid, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_NativeDep_uuid_get) + +static bool js_cc_NativeDep_ext_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ext, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_NativeDep_ext_set) + +static bool js_cc_NativeDep_ext_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ext, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ext, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_NativeDep_ext_get) + +static bool js_cc_NativeDep___isNative___set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->__isNative__); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_NativeDep___isNative___set) + +static bool js_cc_NativeDep___isNative___get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->__isNative__, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_NativeDep___isNative___get) + +static bool js_new_cc_NativeDep__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::NativeDep *result; + result = (cc::NativeDep *)new cc::NativeDep(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_NativeDep__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + bool arg1 ; + ccstd::string arg2 ; + ccstd::string arg3 ; + cc::NativeDep *result; + + ok &= sevalue_to_native(args[0], &arg1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::NativeDep *)new cc::NativeDep(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_NativeDep(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_NativeDep__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_NativeDep__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of NativeDep"); + return false; +} +SE_BIND_CTOR(js_new_cc_NativeDep, __jsb_cc_NativeDep_class, js_delete_cc_NativeDep) + +static bool js_cc_NativeDep_isValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::NativeDep const *)arg1)->isValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_NativeDep_isValid) + +static bool js_delete_cc_NativeDep(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_NativeDep) + +template<> +bool sevalue_to_native(const se::Value &from, cc::NativeDep * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("uuid", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uuid), ctx); + } + + + json->getProperty("ext", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ext), ctx); + } + + + json->getProperty("__isNative__", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->__isNative__), ctx); + } + + + return ok; +} + + +bool js_register_cc_NativeDep(se::Object* obj) { + auto* cls = se::Class::create("NativeDep", obj, nullptr, _SE(js_new_cc_NativeDep)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("uuid", _SE(js_cc_NativeDep_uuid_get), _SE(js_cc_NativeDep_uuid_set)); + cls->defineProperty("ext", _SE(js_cc_NativeDep_ext_get), _SE(js_cc_NativeDep_ext_set)); + cls->defineProperty("__isNative__", _SE(js_cc_NativeDep___isNative___get), _SE(js_cc_NativeDep___isNative___set)); + + cls->defineFunction("isValid", _SE(js_cc_NativeDep_isValid)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_NativeDep)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_NativeDep_proto = cls->getProto(); + __jsb_cc_NativeDep_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IGeometryOptions_class = nullptr; +se::Object* __jsb_cc_IGeometryOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IGeometryOptions) + +static bool js_cc_IGeometryOptions_includeNormal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->includeNormal); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometryOptions_includeNormal_set) + +static bool js_cc_IGeometryOptions_includeNormal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->includeNormal, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometryOptions_includeNormal_get) + +static bool js_cc_IGeometryOptions_includeUV_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->includeUV); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometryOptions_includeUV_set) + +static bool js_cc_IGeometryOptions_includeUV_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->includeUV, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometryOptions_includeUV_get) + +static bool js_new_cc_IGeometryOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IGeometryOptions *result; + result = (cc::IGeometryOptions *)new cc::IGeometryOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IGeometryOptions, __jsb_cc_IGeometryOptions_class, js_delete_cc_IGeometryOptions) + +static bool js_delete_cc_IGeometryOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IGeometryOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometryOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("includeNormal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->includeNormal), ctx); + } + + + json->getProperty("includeUV", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->includeUV), ctx); + } + + + return ok; +} + + +bool js_register_cc_IGeometryOptions(se::Object* obj) { + auto* cls = se::Class::create("IGeometryOptions", obj, nullptr, _SE(js_new_cc_IGeometryOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("includeNormal", _SE(js_cc_IGeometryOptions_includeNormal_get), _SE(js_cc_IGeometryOptions_includeNormal_set)); + cls->defineProperty("includeUV", _SE(js_cc_IGeometryOptions_includeUV_get), _SE(js_cc_IGeometryOptions_includeUV_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IGeometryOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IGeometryOptions_proto = cls->getProto(); + __jsb_cc_IGeometryOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CustomAttribute_class = nullptr; +se::Object* __jsb_cc_CustomAttribute_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CustomAttribute) + +static bool js_cc_CustomAttribute_attr_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attr, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CustomAttribute_attr_set) + +static bool js_cc_CustomAttribute_attr_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attr, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attr, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CustomAttribute_attr_get) + +static bool js_cc_CustomAttribute_values_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->values, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CustomAttribute_values_set) + +static bool js_cc_CustomAttribute_values_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->values, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->values, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CustomAttribute_values_get) + +static bool js_new_cc_CustomAttribute(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::CustomAttribute *result; + result = (cc::CustomAttribute *)new cc::CustomAttribute(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CustomAttribute, __jsb_cc_CustomAttribute_class, js_delete_cc_CustomAttribute) + +static bool js_delete_cc_CustomAttribute(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CustomAttribute) + +template<> +bool sevalue_to_native(const se::Value &from, cc::CustomAttribute * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attr", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attr), ctx); + } + + + json->getProperty("values", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->values), ctx); + } + + + return ok; +} + + +bool js_register_cc_CustomAttribute(se::Object* obj) { + auto* cls = se::Class::create("CustomAttribute", obj, nullptr, _SE(js_new_cc_CustomAttribute)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attr", _SE(js_cc_CustomAttribute_attr_get), _SE(js_cc_CustomAttribute_attr_set)); + cls->defineProperty("values", _SE(js_cc_CustomAttribute_values_get), _SE(js_cc_CustomAttribute_values_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CustomAttribute)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CustomAttribute_proto = cls->getProto(); + __jsb_cc_CustomAttribute_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IGeometry_class = nullptr; +se::Object* __jsb_cc_IGeometry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IGeometry) + +static bool js_cc_IGeometry_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_positions_set) + +static bool js_cc_IGeometry_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_positions_get) + +static bool js_cc_IGeometry_normals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_normals_set) + +static bool js_cc_IGeometry_normals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_normals_get) + +static bool js_cc_IGeometry_uvs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uvs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_uvs_set) + +static bool js_cc_IGeometry_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uvs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uvs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_uvs_get) + +static bool js_cc_IGeometry_tangents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tangents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_tangents_set) + +static bool js_cc_IGeometry_tangents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tangents, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->tangents, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_tangents_get) + +static bool js_cc_IGeometry_colors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_colors_set) + +static bool js_cc_IGeometry_colors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_colors_get) + +static bool js_cc_IGeometry_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_attributes_set) + +static bool js_cc_IGeometry_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_attributes_get) + +static bool js_cc_IGeometry_customAttributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->customAttributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_customAttributes_set) + +static bool js_cc_IGeometry_customAttributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->customAttributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->customAttributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_customAttributes_get) + +static bool js_cc_IGeometry_boundingRadius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->boundingRadius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_boundingRadius_set) + +static bool js_cc_IGeometry_boundingRadius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->boundingRadius, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->boundingRadius, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_boundingRadius_get) + +static bool js_cc_IGeometry_minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_minPos_set) + +static bool js_cc_IGeometry_minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_minPos_get) + +static bool js_cc_IGeometry_maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_maxPos_set) + +static bool js_cc_IGeometry_maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_maxPos_get) + +static bool js_cc_IGeometry_indices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_indices_set) + +static bool js_cc_IGeometry_indices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_indices_get) + +static bool js_cc_IGeometry_primitiveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitiveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_primitiveMode_set) + +static bool js_cc_IGeometry_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitiveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitiveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_primitiveMode_get) + +static bool js_cc_IGeometry_doubleSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->doubleSided, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_doubleSided_set) + +static bool js_cc_IGeometry_doubleSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->doubleSided, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->doubleSided, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_doubleSided_get) + +static bool js_new_cc_IGeometry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IGeometry *result; + result = (cc::IGeometry *)new cc::IGeometry(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IGeometry, __jsb_cc_IGeometry_class, js_delete_cc_IGeometry) + +static bool js_delete_cc_IGeometry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IGeometry) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometry * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("normals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normals), ctx); + } + + + json->getProperty("uvs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uvs), ctx); + } + + + json->getProperty("tangents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tangents), ctx); + } + + + json->getProperty("colors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colors), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("customAttributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->customAttributes), ctx); + } + + + json->getProperty("boundingRadius", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->boundingRadius), ctx); + } + + + json->getProperty("minPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minPos), ctx); + } + + + json->getProperty("maxPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxPos), ctx); + } + + + json->getProperty("indices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices), ctx); + } + + + json->getProperty("primitiveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitiveMode), ctx); + } + + + json->getProperty("doubleSided", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->doubleSided), ctx); + } + + + return ok; +} + + +bool js_register_cc_IGeometry(se::Object* obj) { + auto* cls = se::Class::create("IGeometry", obj, nullptr, _SE(js_new_cc_IGeometry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("positions", _SE(js_cc_IGeometry_positions_get), _SE(js_cc_IGeometry_positions_set)); + cls->defineProperty("normals", _SE(js_cc_IGeometry_normals_get), _SE(js_cc_IGeometry_normals_set)); + cls->defineProperty("uvs", _SE(js_cc_IGeometry_uvs_get), _SE(js_cc_IGeometry_uvs_set)); + cls->defineProperty("tangents", _SE(js_cc_IGeometry_tangents_get), _SE(js_cc_IGeometry_tangents_set)); + cls->defineProperty("colors", _SE(js_cc_IGeometry_colors_get), _SE(js_cc_IGeometry_colors_set)); + cls->defineProperty("attributes", _SE(js_cc_IGeometry_attributes_get), _SE(js_cc_IGeometry_attributes_set)); + cls->defineProperty("customAttributes", _SE(js_cc_IGeometry_customAttributes_get), _SE(js_cc_IGeometry_customAttributes_set)); + cls->defineProperty("boundingRadius", _SE(js_cc_IGeometry_boundingRadius_get), _SE(js_cc_IGeometry_boundingRadius_set)); + cls->defineProperty("minPos", _SE(js_cc_IGeometry_minPos_get), _SE(js_cc_IGeometry_minPos_set)); + cls->defineProperty("maxPos", _SE(js_cc_IGeometry_maxPos_get), _SE(js_cc_IGeometry_maxPos_set)); + cls->defineProperty("indices", _SE(js_cc_IGeometry_indices_get), _SE(js_cc_IGeometry_indices_set)); + cls->defineProperty("primitiveMode", _SE(js_cc_IGeometry_primitiveMode_get), _SE(js_cc_IGeometry_primitiveMode_set)); + cls->defineProperty("doubleSided", _SE(js_cc_IGeometry_doubleSided_get), _SE(js_cc_IGeometry_doubleSided_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IGeometry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IGeometry_proto = cls->getProto(); + __jsb_cc_IGeometry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_DynamicCustomAttribute_class = nullptr; +se::Object* __jsb_cc_DynamicCustomAttribute_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DynamicCustomAttribute) + +static bool js_cc_DynamicCustomAttribute_attr_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attr, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DynamicCustomAttribute_attr_set) + +static bool js_cc_DynamicCustomAttribute_attr_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attr, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attr, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DynamicCustomAttribute_attr_get) + +static bool js_cc_DynamicCustomAttribute_values_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->values, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DynamicCustomAttribute_values_set) + +static bool js_cc_DynamicCustomAttribute_values_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->values, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->values, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DynamicCustomAttribute_values_get) + +static bool js_new_cc_DynamicCustomAttribute(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DynamicCustomAttribute *result; + result = (cc::DynamicCustomAttribute *)new cc::DynamicCustomAttribute(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DynamicCustomAttribute, __jsb_cc_DynamicCustomAttribute_class, js_delete_cc_DynamicCustomAttribute) + +static bool js_delete_cc_DynamicCustomAttribute(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DynamicCustomAttribute) + +template<> +bool sevalue_to_native(const se::Value &from, cc::DynamicCustomAttribute * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attr", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attr), ctx); + } + + + json->getProperty("values", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->values), ctx); + } + + + return ok; +} + + +bool js_register_cc_DynamicCustomAttribute(se::Object* obj) { + auto* cls = se::Class::create("DynamicCustomAttribute", obj, nullptr, _SE(js_new_cc_DynamicCustomAttribute)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attr", _SE(js_cc_DynamicCustomAttribute_attr_get), _SE(js_cc_DynamicCustomAttribute_attr_set)); + cls->defineProperty("values", _SE(js_cc_DynamicCustomAttribute_values_get), _SE(js_cc_DynamicCustomAttribute_values_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DynamicCustomAttribute)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DynamicCustomAttribute_proto = cls->getProto(); + __jsb_cc_DynamicCustomAttribute_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDynamicGeometry_class = nullptr; +se::Object* __jsb_cc_IDynamicGeometry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDynamicGeometry) + +static bool js_cc_IDynamicGeometry_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_positions_set) + +static bool js_cc_IDynamicGeometry_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_positions_get) + +static bool js_cc_IDynamicGeometry_normals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_normals_set) + +static bool js_cc_IDynamicGeometry_normals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_normals_get) + +static bool js_cc_IDynamicGeometry_uvs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uvs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_uvs_set) + +static bool js_cc_IDynamicGeometry_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uvs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uvs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_uvs_get) + +static bool js_cc_IDynamicGeometry_tangents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tangents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_tangents_set) + +static bool js_cc_IDynamicGeometry_tangents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tangents, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->tangents, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_tangents_get) + +static bool js_cc_IDynamicGeometry_colors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_colors_set) + +static bool js_cc_IDynamicGeometry_colors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_colors_get) + +static bool js_cc_IDynamicGeometry_customAttributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->customAttributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_customAttributes_set) + +static bool js_cc_IDynamicGeometry_customAttributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->customAttributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->customAttributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_customAttributes_get) + +static bool js_cc_IDynamicGeometry_minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_minPos_set) + +static bool js_cc_IDynamicGeometry_minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_minPos_get) + +static bool js_cc_IDynamicGeometry_maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_maxPos_set) + +static bool js_cc_IDynamicGeometry_maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_maxPos_get) + +static bool js_cc_IDynamicGeometry_indices16_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices16, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_indices16_set) + +static bool js_cc_IDynamicGeometry_indices16_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices16, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices16, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_indices16_get) + +static bool js_cc_IDynamicGeometry_indices32_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices32, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_indices32_set) + +static bool js_cc_IDynamicGeometry_indices32_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices32, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices32, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_indices32_get) + +static bool js_cc_IDynamicGeometry_primitiveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitiveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_primitiveMode_set) + +static bool js_cc_IDynamicGeometry_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitiveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitiveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_primitiveMode_get) + +static bool js_cc_IDynamicGeometry_doubleSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->doubleSided, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_doubleSided_set) + +static bool js_cc_IDynamicGeometry_doubleSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->doubleSided, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->doubleSided, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_doubleSided_get) + +static bool js_new_cc_IDynamicGeometry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDynamicGeometry *result; + result = (cc::IDynamicGeometry *)new cc::IDynamicGeometry(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDynamicGeometry, __jsb_cc_IDynamicGeometry_class, js_delete_cc_IDynamicGeometry) + +static bool js_delete_cc_IDynamicGeometry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDynamicGeometry) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDynamicGeometry * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("normals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normals), ctx); + } + + + json->getProperty("uvs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uvs), ctx); + } + + + json->getProperty("tangents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tangents), ctx); + } + + + json->getProperty("colors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colors), ctx); + } + + + json->getProperty("customAttributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->customAttributes), ctx); + } + + + json->getProperty("minPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minPos), ctx); + } + + + json->getProperty("maxPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxPos), ctx); + } + + + json->getProperty("indices16", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices16), ctx); + } + + + json->getProperty("indices32", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices32), ctx); + } + + + json->getProperty("primitiveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitiveMode), ctx); + } + + + json->getProperty("doubleSided", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->doubleSided), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDynamicGeometry(se::Object* obj) { + auto* cls = se::Class::create("IDynamicGeometry", obj, nullptr, _SE(js_new_cc_IDynamicGeometry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("positions", _SE(js_cc_IDynamicGeometry_positions_get), _SE(js_cc_IDynamicGeometry_positions_set)); + cls->defineProperty("normals", _SE(js_cc_IDynamicGeometry_normals_get), _SE(js_cc_IDynamicGeometry_normals_set)); + cls->defineProperty("uvs", _SE(js_cc_IDynamicGeometry_uvs_get), _SE(js_cc_IDynamicGeometry_uvs_set)); + cls->defineProperty("tangents", _SE(js_cc_IDynamicGeometry_tangents_get), _SE(js_cc_IDynamicGeometry_tangents_set)); + cls->defineProperty("colors", _SE(js_cc_IDynamicGeometry_colors_get), _SE(js_cc_IDynamicGeometry_colors_set)); + cls->defineProperty("customAttributes", _SE(js_cc_IDynamicGeometry_customAttributes_get), _SE(js_cc_IDynamicGeometry_customAttributes_set)); + cls->defineProperty("minPos", _SE(js_cc_IDynamicGeometry_minPos_get), _SE(js_cc_IDynamicGeometry_minPos_set)); + cls->defineProperty("maxPos", _SE(js_cc_IDynamicGeometry_maxPos_get), _SE(js_cc_IDynamicGeometry_maxPos_set)); + cls->defineProperty("indices16", _SE(js_cc_IDynamicGeometry_indices16_get), _SE(js_cc_IDynamicGeometry_indices16_set)); + cls->defineProperty("indices32", _SE(js_cc_IDynamicGeometry_indices32_get), _SE(js_cc_IDynamicGeometry_indices32_set)); + cls->defineProperty("primitiveMode", _SE(js_cc_IDynamicGeometry_primitiveMode_get), _SE(js_cc_IDynamicGeometry_primitiveMode_set)); + cls->defineProperty("doubleSided", _SE(js_cc_IDynamicGeometry_doubleSided_get), _SE(js_cc_IDynamicGeometry_doubleSided_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDynamicGeometry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDynamicGeometry_proto = cls->getProto(); + __jsb_cc_IDynamicGeometry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Asset_class = nullptr; +se::Object* __jsb_cc_Asset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Asset) + +static bool js_new_cc_Asset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Asset *result; + result = (cc::Asset *)new cc::Asset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Asset, __jsb_cc_Asset_class, js_delete_cc_Asset) + +static bool js_delete_cc_Asset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Asset) + +static bool js_cc_Asset_getNativeAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Asset const *)arg1)->getNativeAsset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_getNativeAsset) + +static bool js_cc_Asset_setNativeAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any *arg2 = 0 ; + ccstd::any temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setNativeAsset((ccstd::any const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_setNativeAsset) + +static bool js_cc_Asset_addAssetRef(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->addAssetRef(); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_addAssetRef) + +static bool js_cc_Asset_decAssetRef__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->decAssetRef(arg2); + + + return true; +} + +static bool js_cc_Asset_decAssetRef__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->decAssetRef(); + + + return true; +} + +static bool js_cc_Asset_decAssetRef(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Asset_decAssetRef__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Asset_decAssetRef__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Asset_decAssetRef) + +static bool js_cc_Asset_getAssetRefCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Asset const *)arg1)->getAssetRefCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_getAssetRefCount) + +static bool js_cc_Asset_onLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onLoaded(); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_onLoaded) + +static bool js_cc_Asset_initDefault__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initDefault(); + + + return true; +} + +static bool js_cc_Asset_initDefault__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::optional< ccstd::string > *arg2 = 0 ; + ccstd::optional< ccstd::string > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initDefault((ccstd::optional< ccstd::string > const &)*arg2); + + + return true; +} + +static bool js_cc_Asset_initDefault(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_Asset_initDefault__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Asset_initDefault__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Asset_initDefault) + +static bool js_cc_Asset_validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Asset const *)arg1)->validate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_validate) + +static bool js_cc_Asset_serialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any *arg2 = 0 ; + ccstd::any temp2 ; + ccstd::any result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->serialize((ccstd::any const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_serialize) + +static bool js_cc_Asset_deserialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any *arg2 = 0 ; + ccstd::any *arg3 = 0 ; + ccstd::any temp2 ; + ccstd::any temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->deserialize((ccstd::any const &)*arg2,(ccstd::any const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_deserialize) + +static bool js_cc_Asset__native_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_native, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Asset__native_set) + +static bool js_cc_Asset__native_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_native, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_native, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Asset__native_get) + +static bool js_cc_Asset__nativeUrl_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_nativeUrl, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Asset__nativeUrl_set) + +static bool js_cc_Asset__nativeUrl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_nativeUrl, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_nativeUrl, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Asset__nativeUrl_get) + +static bool js_cc_Asset__uuid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Asset__uuid_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Asset__uuid_set) + +static bool js_cc_Asset__uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_Asset__uuid_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_Asset__uuid_get) + +static bool js_cc_Asset_uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_Asset_uuid_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_Asset_uuid_get) + +static bool js_cc_Asset_nativeUrl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Asset_nativeUrl_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_Asset_nativeUrl_get) + +static bool js_cc_Asset__nativeDep_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + cc::NativeDep result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Asset__nativeDep_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_Asset__nativeDep_get) + +static bool js_cc_Asset_isDefault_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Asset_isDefault_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Asset_isDefault_get) + +bool js_register_cc_Asset(se::Object* obj) { + auto* cls = se::Class::create("Asset", obj, __jsb_cc_CCObject_proto, _SE(js_new_cc_Asset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_native", _SE(js_cc_Asset__native_get), _SE(js_cc_Asset__native_set)); + cls->defineProperty("_nativeUrl", _SE(js_cc_Asset__nativeUrl_get), _SE(js_cc_Asset__nativeUrl_set)); + cls->defineProperty("_uuid", _SE(js_cc_Asset__uuid_get), _SE(js_cc_Asset__uuid_set)); + cls->defineProperty("uuid", _SE(js_cc_Asset_uuid_get), nullptr); + cls->defineProperty("nativeUrl", _SE(js_cc_Asset_nativeUrl_get), nullptr); + cls->defineProperty("_nativeDep", _SE(js_cc_Asset__nativeDep_get), nullptr); + cls->defineProperty("isDefault", _SE(js_cc_Asset_isDefault_get), nullptr); + + cls->defineFunction("getNativeAsset", _SE(js_cc_Asset_getNativeAsset)); + cls->defineFunction("setNativeAsset", _SE(js_cc_Asset_setNativeAsset)); + cls->defineFunction("addAssetRef", _SE(js_cc_Asset_addAssetRef)); + cls->defineFunction("decAssetRef", _SE(js_cc_Asset_decAssetRef)); + cls->defineFunction("getAssetRefCount", _SE(js_cc_Asset_getAssetRefCount)); + cls->defineFunction("onLoaded", _SE(js_cc_Asset_onLoaded)); + cls->defineFunction("initDefault", _SE(js_cc_Asset_initDefault)); + cls->defineFunction("validate", _SE(js_cc_Asset_validate)); + cls->defineFunction("serialize", _SE(js_cc_Asset_serialize)); + cls->defineFunction("deserialize", _SE(js_cc_Asset_deserialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Asset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Asset_proto = cls->getProto(); + __jsb_cc_Asset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureBase_class = nullptr; +se::Object* __jsb_cc_TextureBase_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureBase) + +static bool js_new_cc_TextureBase(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureBase *result; + result = (cc::TextureBase *)new cc::TextureBase(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureBase, __jsb_cc_TextureBase_class, js_delete_cc_TextureBase) + +static bool js_delete_cc_TextureBase(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureBase) + +static bool js_cc_TextureBase_getId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + ccstd::string *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(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &((cc::TextureBase const *)arg1)->getId(); + + 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_TextureBase_getId) + +static bool js_cc_TextureBase_getPixelFormat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::PixelFormat result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureBase::PixelFormat)((cc::TextureBase const *)arg1)->getPixelFormat(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_getPixelFormat) + +static bool js_cc_TextureBase_getAnisotropy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::TextureBase const *)arg1)->getAnisotropy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_getAnisotropy) + +static bool js_cc_TextureBase_setWrapMode__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::WrapMode arg2 ; + cc::TextureBase::WrapMode arg3 ; + cc::TextureBase::WrapMode arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setWrapMode(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_TextureBase_setWrapMode__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::WrapMode arg2 ; + cc::TextureBase::WrapMode arg3 ; + + arg1 = SE_THIS_OBJECT(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)->setWrapMode(arg2,arg3); + + + return true; +} + +static bool js_cc_TextureBase_setWrapMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_TextureBase_setWrapMode__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_TextureBase_setWrapMode__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_TextureBase_setWrapMode) + +static bool js_cc_TextureBase_setFilters(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::Filter arg2 ; + cc::TextureBase::Filter arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFilters(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_setFilters) + +static bool js_cc_TextureBase_setMipFilter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::Filter arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMipFilter(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_setMipFilter) + +static bool js_cc_TextureBase_setAnisotropy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setAnisotropy(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_setAnisotropy) + +static bool js_cc_TextureBase_getHash(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + ccstd::hash_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::TextureBase const *)arg1)->getHash(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_getHash) + +static bool js_cc_TextureBase_getGFXTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::gfx::Texture *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)((cc::TextureBase const *)arg1)->getGFXTexture(); + + 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_TextureBase_getGFXTexture) + +static bool js_cc_TextureBase_getSamplerInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::gfx::SamplerInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SamplerInfo *) &((cc::TextureBase const *)arg1)->getSamplerInfo(); + + 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_TextureBase_getSamplerInfo) + +static bool js_cc_TextureBase_getGFXSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::TextureBase const *)arg1)->getGFXSampler(); + + 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_TextureBase_getGFXSampler) + +static bool js_cc_TextureBase__format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__format_set) + +static bool js_cc_TextureBase__format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__format_get) + +static bool js_cc_TextureBase__minFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_minFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__minFilter_set) + +static bool js_cc_TextureBase__minFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_minFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_minFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__minFilter_get) + +static bool js_cc_TextureBase__magFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_magFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__magFilter_set) + +static bool js_cc_TextureBase__magFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_magFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_magFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__magFilter_get) + +static bool js_cc_TextureBase__mipFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_mipFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__mipFilter_set) + +static bool js_cc_TextureBase__mipFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_mipFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_mipFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__mipFilter_get) + +static bool js_cc_TextureBase__wrapS_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_wrapS, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__wrapS_set) + +static bool js_cc_TextureBase__wrapS_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_wrapS, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_wrapS, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__wrapS_get) + +static bool js_cc_TextureBase__wrapT_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_wrapT, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__wrapT_set) + +static bool js_cc_TextureBase__wrapT_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_wrapT, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_wrapT, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__wrapT_get) + +static bool js_cc_TextureBase__wrapR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_wrapR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__wrapR_set) + +static bool js_cc_TextureBase__wrapR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_wrapR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_wrapR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__wrapR_get) + +static bool js_cc_TextureBase__anisotropy_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_anisotropy, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__anisotropy_set) + +static bool js_cc_TextureBase__anisotropy_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_anisotropy, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__anisotropy_get) + +static bool js_cc_TextureBase_isCompressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_TextureBase_isCompressed_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_isCompressed_get) + +static bool js_cc_TextureBase_isAlphaAtlas_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_TextureBase_isAlphaAtlas_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_isAlphaAtlas_get) + +static bool js_cc_TextureBase__width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase__width_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__width_set) + +static bool js_cc_TextureBase__width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase__width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__width_get) + +static bool js_cc_TextureBase_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase_width_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase_width_set) + +static bool js_cc_TextureBase_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_width_get) + +static bool js_cc_TextureBase__height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase__height_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__height_set) + +static bool js_cc_TextureBase__height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase__height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__height_get) + +static bool js_cc_TextureBase_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase_height_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase_height_set) + +static bool js_cc_TextureBase_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_height_get) + +bool js_register_cc_TextureBase(se::Object* obj) { + auto* cls = se::Class::create("TextureBase", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_TextureBase)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_format", _SE(js_cc_TextureBase__format_get), _SE(js_cc_TextureBase__format_set)); + cls->defineProperty("_minFilter", _SE(js_cc_TextureBase__minFilter_get), _SE(js_cc_TextureBase__minFilter_set)); + cls->defineProperty("_magFilter", _SE(js_cc_TextureBase__magFilter_get), _SE(js_cc_TextureBase__magFilter_set)); + cls->defineProperty("_mipFilter", _SE(js_cc_TextureBase__mipFilter_get), _SE(js_cc_TextureBase__mipFilter_set)); + cls->defineProperty("_wrapS", _SE(js_cc_TextureBase__wrapS_get), _SE(js_cc_TextureBase__wrapS_set)); + cls->defineProperty("_wrapT", _SE(js_cc_TextureBase__wrapT_get), _SE(js_cc_TextureBase__wrapT_set)); + cls->defineProperty("_wrapR", _SE(js_cc_TextureBase__wrapR_get), _SE(js_cc_TextureBase__wrapR_set)); + cls->defineProperty("_anisotropy", _SE(js_cc_TextureBase__anisotropy_get), _SE(js_cc_TextureBase__anisotropy_set)); + cls->defineProperty("isCompressed", _SE(js_cc_TextureBase_isCompressed_get), nullptr); + cls->defineProperty("isAlphaAtlas", _SE(js_cc_TextureBase_isAlphaAtlas_get), nullptr); + cls->defineProperty("_width", _SE(js_cc_TextureBase__width_get), _SE(js_cc_TextureBase__width_set)); + cls->defineProperty("width", _SE(js_cc_TextureBase_width_get), _SE(js_cc_TextureBase_width_set)); + cls->defineProperty("_height", _SE(js_cc_TextureBase__height_get), _SE(js_cc_TextureBase__height_set)); + cls->defineProperty("height", _SE(js_cc_TextureBase_height_get), _SE(js_cc_TextureBase_height_set)); + + cls->defineFunction("getId", _SE(js_cc_TextureBase_getId)); + cls->defineFunction("getPixelFormat", _SE(js_cc_TextureBase_getPixelFormat)); + cls->defineFunction("getAnisotropy", _SE(js_cc_TextureBase_getAnisotropy)); + cls->defineFunction("setWrapMode", _SE(js_cc_TextureBase_setWrapMode)); + cls->defineFunction("setFilters", _SE(js_cc_TextureBase_setFilters)); + cls->defineFunction("setMipFilter", _SE(js_cc_TextureBase_setMipFilter)); + cls->defineFunction("setAnisotropy", _SE(js_cc_TextureBase_setAnisotropy)); + cls->defineFunction("getHash", _SE(js_cc_TextureBase_getHash)); + cls->defineFunction("getGFXTexture", _SE(js_cc_TextureBase_getGFXTexture)); + cls->defineFunction("getSamplerInfo", _SE(js_cc_TextureBase_getSamplerInfo)); + cls->defineFunction("getGFXSampler", _SE(js_cc_TextureBase_getGFXSampler)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureBase)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureBase_proto = cls->getProto(); + __jsb_cc_TextureBase_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SimpleTexture_class = nullptr; +se::Object* __jsb_cc_SimpleTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SimpleTexture) + +static bool js_delete_cc_SimpleTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SimpleTexture) + +static bool js_cc_SimpleTexture_updateImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateImage(); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_updateImage) + +static bool js_cc_SimpleTexture_updateMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateMipmaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_updateMipmaps) + +static bool js_cc_SimpleTexture_uploadData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + uint32_t arg3 ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->uploadData((uint8_t const *)arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SimpleTexture_uploadData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->uploadData((uint8_t const *)arg2,arg3); + + + return true; +} + +static bool js_cc_SimpleTexture_uploadData__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->uploadData((uint8_t const *)arg2); + + + return true; +} + +static bool js_cc_SimpleTexture_uploadData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SimpleTexture_uploadData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SimpleTexture_uploadData__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SimpleTexture_uploadData__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SimpleTexture_uploadData) + +static bool js_cc_SimpleTexture_assignImage__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + cc::ImageAsset *arg2 = (cc::ImageAsset *) NULL ; + uint32_t arg3 ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->assignImage(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SimpleTexture_assignImage__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + cc::ImageAsset *arg2 = (cc::ImageAsset *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->assignImage(arg2,arg3); + + + return true; +} + +static bool js_cc_SimpleTexture_assignImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SimpleTexture_assignImage__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SimpleTexture_assignImage__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SimpleTexture_assignImage) + +static bool js_cc_SimpleTexture_checkTextureLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->checkTextureLoaded(); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_checkTextureLoaded) + +static bool js_cc_SimpleTexture_setMipmapLevel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMipmapLevel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_setMipmapLevel) + +static bool js_cc_SimpleTexture_setMipRange(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipRange(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_setMipRange) + +static bool js_cc_SimpleTexture_isUsingOfflineMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isUsingOfflineMipmaps(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_isUsingOfflineMipmaps) + +static bool js_cc_SimpleTexture_mipmapLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_SimpleTexture_mipmapLevel_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_SimpleTexture_mipmapLevel_get) + +bool js_register_cc_SimpleTexture(se::Object* obj) { + auto* cls = se::Class::create("SimpleTexture", obj, __jsb_cc_TextureBase_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mipmapLevel", _SE(js_cc_SimpleTexture_mipmapLevel_get), nullptr); + + cls->defineFunction("updateImage", _SE(js_cc_SimpleTexture_updateImage)); + cls->defineFunction("updateMipmaps", _SE(js_cc_SimpleTexture_updateMipmaps)); + cls->defineFunction("uploadData", _SE(js_cc_SimpleTexture_uploadData)); + cls->defineFunction("assignImage", _SE(js_cc_SimpleTexture_assignImage)); + cls->defineFunction("checkTextureLoaded", _SE(js_cc_SimpleTexture_checkTextureLoaded)); + cls->defineFunction("setMipmapLevel", _SE(js_cc_SimpleTexture_setMipmapLevel)); + cls->defineFunction("setMipRange", _SE(js_cc_SimpleTexture_setMipRange)); + cls->defineFunction("isUsingOfflineMipmaps", _SE(js_cc_SimpleTexture_isUsingOfflineMipmaps)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SimpleTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SimpleTexture_proto = cls->getProto(); + __jsb_cc_SimpleTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITexture2DSerializeData_class = nullptr; +se::Object* __jsb_cc_ITexture2DSerializeData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITexture2DSerializeData) + +static bool js_cc_ITexture2DSerializeData_base_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->base, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DSerializeData_base_set) + +static bool js_cc_ITexture2DSerializeData_base_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->base, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->base, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DSerializeData_base_get) + +static bool js_cc_ITexture2DSerializeData_mipmaps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmaps, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DSerializeData_mipmaps_set) + +static bool js_cc_ITexture2DSerializeData_mipmaps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmaps, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmaps, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DSerializeData_mipmaps_get) + +static bool js_new_cc_ITexture2DSerializeData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITexture2DSerializeData *result; + result = (cc::ITexture2DSerializeData *)new cc::ITexture2DSerializeData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITexture2DSerializeData, __jsb_cc_ITexture2DSerializeData_class, js_delete_cc_ITexture2DSerializeData) + +static bool js_delete_cc_ITexture2DSerializeData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITexture2DSerializeData) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DSerializeData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("base", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->base), ctx); + } + + + json->getProperty("mipmaps", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmaps), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITexture2DSerializeData(se::Object* obj) { + auto* cls = se::Class::create("ITexture2DSerializeData", obj, nullptr, _SE(js_new_cc_ITexture2DSerializeData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("base", _SE(js_cc_ITexture2DSerializeData_base_get), _SE(js_cc_ITexture2DSerializeData_base_set)); + cls->defineProperty("mipmaps", _SE(js_cc_ITexture2DSerializeData_mipmaps_get), _SE(js_cc_ITexture2DSerializeData_mipmaps_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITexture2DSerializeData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITexture2DSerializeData_proto = cls->getProto(); + __jsb_cc_ITexture2DSerializeData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITexture2DCreateInfo_class = nullptr; +se::Object* __jsb_cc_ITexture2DCreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITexture2DCreateInfo) + +static bool js_cc_ITexture2DCreateInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_width_set) + +static bool js_cc_ITexture2DCreateInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_width_get) + +static bool js_cc_ITexture2DCreateInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_height_set) + +static bool js_cc_ITexture2DCreateInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_height_get) + +static bool js_cc_ITexture2DCreateInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_format_set) + +static bool js_cc_ITexture2DCreateInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_format_get) + +static bool js_cc_ITexture2DCreateInfo_mipmapLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_mipmapLevel_set) + +static bool js_cc_ITexture2DCreateInfo_mipmapLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapLevel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapLevel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_mipmapLevel_get) + +static bool js_cc_ITexture2DCreateInfo_baseLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_baseLevel_set) + +static bool js_cc_ITexture2DCreateInfo_baseLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseLevel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->baseLevel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_baseLevel_get) + +static bool js_cc_ITexture2DCreateInfo_maxLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_maxLevel_set) + +static bool js_cc_ITexture2DCreateInfo_maxLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxLevel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxLevel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_maxLevel_get) + +static bool js_new_cc_ITexture2DCreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITexture2DCreateInfo *result; + result = (cc::ITexture2DCreateInfo *)new cc::ITexture2DCreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITexture2DCreateInfo, __jsb_cc_ITexture2DCreateInfo_class, js_delete_cc_ITexture2DCreateInfo) + +static bool js_delete_cc_ITexture2DCreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITexture2DCreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DCreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("mipmapLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapLevel), ctx); + } + + + json->getProperty("baseLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseLevel), ctx); + } + + + json->getProperty("maxLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxLevel), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITexture2DCreateInfo(se::Object* obj) { + auto* cls = se::Class::create("ITexture2DCreateInfo", obj, nullptr, _SE(js_new_cc_ITexture2DCreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_ITexture2DCreateInfo_width_get), _SE(js_cc_ITexture2DCreateInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_ITexture2DCreateInfo_height_get), _SE(js_cc_ITexture2DCreateInfo_height_set)); + cls->defineProperty("format", _SE(js_cc_ITexture2DCreateInfo_format_get), _SE(js_cc_ITexture2DCreateInfo_format_set)); + cls->defineProperty("mipmapLevel", _SE(js_cc_ITexture2DCreateInfo_mipmapLevel_get), _SE(js_cc_ITexture2DCreateInfo_mipmapLevel_set)); + cls->defineProperty("baseLevel", _SE(js_cc_ITexture2DCreateInfo_baseLevel_get), _SE(js_cc_ITexture2DCreateInfo_baseLevel_set)); + cls->defineProperty("maxLevel", _SE(js_cc_ITexture2DCreateInfo_maxLevel_get), _SE(js_cc_ITexture2DCreateInfo_maxLevel_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITexture2DCreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITexture2DCreateInfo_proto = cls->getProto(); + __jsb_cc_ITexture2DCreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Texture2D_class = nullptr; +se::Object* __jsb_cc_Texture2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Texture2D) + +static bool js_new_cc_Texture2D(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Texture2D *result; + result = (cc::Texture2D *)new cc::Texture2D(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Texture2D, __jsb_cc_Texture2D_class, js_delete_cc_Texture2D) + +static bool js_delete_cc_Texture2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Texture2D) + +static bool js_cc_Texture2D_getMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *) &((cc::Texture2D const *)arg1)->getMipmaps(); + + 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_Texture2D_getMipmaps) + +static bool js_cc_Texture2D_getMipmapsUuids(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< ccstd::string > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &((cc::Texture2D const *)arg1)->getMipmapsUuids(); + + 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_Texture2D_getMipmapsUuids) + +static bool js_cc_Texture2D_syncMipmapsForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->syncMipmapsForJS((ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_syncMipmapsForJS) + +static bool js_cc_Texture2D_setMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmaps((ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_setMipmaps) + +static bool js_cc_Texture2D_getImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::ImageAsset *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(s); + if (nullptr == arg1) return true; + result = (cc::ImageAsset *)((cc::Texture2D const *)arg1)->getImage(); + + 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_Texture2D_getImage) + +static bool js_cc_Texture2D_setImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::ImageAsset *arg2 = (cc::ImageAsset *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setImage(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_setImage) + +static bool js_cc_Texture2D_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_initialize) + +static bool js_cc_Texture2D_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::ITexture2DCreateInfo *arg2 = 0 ; + cc::ITexture2DCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::ITexture2DCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_reset) + +static bool js_cc_Texture2D_create__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->create(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->create(arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + uint32_t arg5 ; + + arg1 = SE_THIS_OBJECT(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)->create(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + + arg1 = SE_THIS_OBJECT(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)->create(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->create(arg2,arg3); + + + return true; +} + +static bool js_cc_Texture2D_create(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_Texture2D_create__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_Texture2D_create__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Texture2D_create__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_Texture2D_create__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Texture2D_create__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Texture2D_create) + +static bool js_cc_Texture2D_description(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Texture2D const *)arg1)->description(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_description) + +static bool js_cc_Texture2D_releaseTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->releaseTexture(); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_releaseTexture) + +static bool js_cc_Texture2D_getGfxTextureCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::gfx::TextureUsageBit arg2 ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + cc::gfx::TextureFlagBit arg5 ; + cc::gfx::TextureInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_getGfxTextureCreateInfo) + +static bool js_cc_Texture2D_getGfxTextureViewCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::gfx::TextureViewInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureViewCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_getGfxTextureViewCreateInfo) + +bool js_register_cc_Texture2D(se::Object* obj) { + auto* cls = se::Class::create("Texture2D", obj, __jsb_cc_SimpleTexture_proto, _SE(js_new_cc_Texture2D)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getMipmaps", _SE(js_cc_Texture2D_getMipmaps)); + cls->defineFunction("getMipmapsUuids", _SE(js_cc_Texture2D_getMipmapsUuids)); + cls->defineFunction("syncMipmapsForJS", _SE(js_cc_Texture2D_syncMipmapsForJS)); + cls->defineFunction("setMipmaps", _SE(js_cc_Texture2D_setMipmaps)); + cls->defineFunction("getImage", _SE(js_cc_Texture2D_getImage)); + cls->defineFunction("setImage", _SE(js_cc_Texture2D_setImage)); + cls->defineFunction("initialize", _SE(js_cc_Texture2D_initialize)); + cls->defineFunction("reset", _SE(js_cc_Texture2D_reset)); + cls->defineFunction("create", _SE(js_cc_Texture2D_create)); + cls->defineFunction("description", _SE(js_cc_Texture2D_description)); + cls->defineFunction("releaseTexture", _SE(js_cc_Texture2D_releaseTexture)); + cls->defineFunction("getGfxTextureCreateInfo", _SE(js_cc_Texture2D_getGfxTextureCreateInfo)); + cls->defineFunction("getGfxTextureViewCreateInfo", _SE(js_cc_Texture2D_getGfxTextureViewCreateInfo)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Texture2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Texture2D_proto = cls->getProto(); + __jsb_cc_Texture2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITextureCubeMipmap_class = nullptr; +se::Object* __jsb_cc_ITextureCubeMipmap_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITextureCubeMipmap) + +static bool js_cc_ITextureCubeMipmap_front_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->front, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_front_set) + +static bool js_cc_ITextureCubeMipmap_front_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->front, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->front, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_front_get) + +static bool js_cc_ITextureCubeMipmap_back_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->back, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_back_set) + +static bool js_cc_ITextureCubeMipmap_back_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->back, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->back, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_back_get) + +static bool js_cc_ITextureCubeMipmap_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_left_set) + +static bool js_cc_ITextureCubeMipmap_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->left, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_left_get) + +static bool js_cc_ITextureCubeMipmap_right_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->right, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_right_set) + +static bool js_cc_ITextureCubeMipmap_right_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->right, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->right, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_right_get) + +static bool js_cc_ITextureCubeMipmap_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_top_set) + +static bool js_cc_ITextureCubeMipmap_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->top, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_top_get) + +static bool js_cc_ITextureCubeMipmap_bottom_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bottom, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_bottom_set) + +static bool js_cc_ITextureCubeMipmap_bottom_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bottom, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bottom, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_bottom_get) + +static bool js_new_cc_ITextureCubeMipmap(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITextureCubeMipmap *result; + result = (cc::ITextureCubeMipmap *)new cc::ITextureCubeMipmap(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITextureCubeMipmap, __jsb_cc_ITextureCubeMipmap_class, js_delete_cc_ITextureCubeMipmap) + +static bool js_delete_cc_ITextureCubeMipmap(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITextureCubeMipmap) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeMipmap * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("front", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->front), ctx); + } + + + json->getProperty("back", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->back), ctx); + } + + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("right", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->right), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("bottom", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bottom), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITextureCubeMipmap(se::Object* obj) { + auto* cls = se::Class::create("ITextureCubeMipmap", obj, nullptr, _SE(js_new_cc_ITextureCubeMipmap)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("front", _SE(js_cc_ITextureCubeMipmap_front_get), _SE(js_cc_ITextureCubeMipmap_front_set)); + cls->defineProperty("back", _SE(js_cc_ITextureCubeMipmap_back_get), _SE(js_cc_ITextureCubeMipmap_back_set)); + cls->defineProperty("left", _SE(js_cc_ITextureCubeMipmap_left_get), _SE(js_cc_ITextureCubeMipmap_left_set)); + cls->defineProperty("right", _SE(js_cc_ITextureCubeMipmap_right_get), _SE(js_cc_ITextureCubeMipmap_right_set)); + cls->defineProperty("top", _SE(js_cc_ITextureCubeMipmap_top_get), _SE(js_cc_ITextureCubeMipmap_top_set)); + cls->defineProperty("bottom", _SE(js_cc_ITextureCubeMipmap_bottom_get), _SE(js_cc_ITextureCubeMipmap_bottom_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITextureCubeMipmap)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITextureCubeMipmap_proto = cls->getProto(); + __jsb_cc_ITextureCubeMipmap_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITextureCubeSerializeMipmapData_class = nullptr; +se::Object* __jsb_cc_ITextureCubeSerializeMipmapData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITextureCubeSerializeMipmapData) + +static bool js_cc_ITextureCubeSerializeMipmapData_front_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->front, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_front_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_front_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->front, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->front, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_front_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_back_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->back, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_back_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_back_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->back, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->back, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_back_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_left_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->left, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_left_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_right_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->right, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_right_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_right_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->right, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->right, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_right_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_top_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->top, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_top_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_bottom_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bottom, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_bottom_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_bottom_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bottom, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bottom, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_bottom_get) + +static bool js_new_cc_ITextureCubeSerializeMipmapData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITextureCubeSerializeMipmapData *result; + result = (cc::ITextureCubeSerializeMipmapData *)new cc::ITextureCubeSerializeMipmapData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITextureCubeSerializeMipmapData, __jsb_cc_ITextureCubeSerializeMipmapData_class, js_delete_cc_ITextureCubeSerializeMipmapData) + +static bool js_delete_cc_ITextureCubeSerializeMipmapData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITextureCubeSerializeMipmapData) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeSerializeMipmapData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("front", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->front), ctx); + } + + + json->getProperty("back", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->back), ctx); + } + + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("right", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->right), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("bottom", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bottom), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITextureCubeSerializeMipmapData(se::Object* obj) { + auto* cls = se::Class::create("ITextureCubeSerializeMipmapData", obj, nullptr, _SE(js_new_cc_ITextureCubeSerializeMipmapData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("front", _SE(js_cc_ITextureCubeSerializeMipmapData_front_get), _SE(js_cc_ITextureCubeSerializeMipmapData_front_set)); + cls->defineProperty("back", _SE(js_cc_ITextureCubeSerializeMipmapData_back_get), _SE(js_cc_ITextureCubeSerializeMipmapData_back_set)); + cls->defineProperty("left", _SE(js_cc_ITextureCubeSerializeMipmapData_left_get), _SE(js_cc_ITextureCubeSerializeMipmapData_left_set)); + cls->defineProperty("right", _SE(js_cc_ITextureCubeSerializeMipmapData_right_get), _SE(js_cc_ITextureCubeSerializeMipmapData_right_set)); + cls->defineProperty("top", _SE(js_cc_ITextureCubeSerializeMipmapData_top_get), _SE(js_cc_ITextureCubeSerializeMipmapData_top_set)); + cls->defineProperty("bottom", _SE(js_cc_ITextureCubeSerializeMipmapData_bottom_get), _SE(js_cc_ITextureCubeSerializeMipmapData_bottom_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITextureCubeSerializeMipmapData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITextureCubeSerializeMipmapData_proto = cls->getProto(); + __jsb_cc_ITextureCubeSerializeMipmapData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MipmapAtlasLayoutInfo_class = nullptr; +se::Object* __jsb_cc_MipmapAtlasLayoutInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MipmapAtlasLayoutInfo) + +static bool js_cc_MipmapAtlasLayoutInfo_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_left_set) + +static bool js_cc_MipmapAtlasLayoutInfo_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_left_get) + +static bool js_cc_MipmapAtlasLayoutInfo_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_top_set) + +static bool js_cc_MipmapAtlasLayoutInfo_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_top_get) + +static bool js_cc_MipmapAtlasLayoutInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_width_set) + +static bool js_cc_MipmapAtlasLayoutInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_width_get) + +static bool js_cc_MipmapAtlasLayoutInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_height_set) + +static bool js_cc_MipmapAtlasLayoutInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_height_get) + +static bool js_cc_MipmapAtlasLayoutInfo_level_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->level, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_level_set) + +static bool js_cc_MipmapAtlasLayoutInfo_level_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->level, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_level_get) + +static bool js_new_cc_MipmapAtlasLayoutInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MipmapAtlasLayoutInfo *result; + result = (cc::MipmapAtlasLayoutInfo *)new cc::MipmapAtlasLayoutInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MipmapAtlasLayoutInfo, __jsb_cc_MipmapAtlasLayoutInfo_class, js_delete_cc_MipmapAtlasLayoutInfo) + +static bool js_delete_cc_MipmapAtlasLayoutInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MipmapAtlasLayoutInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::MipmapAtlasLayoutInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("level", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->level), ctx); + } + + + return ok; +} + + +bool js_register_cc_MipmapAtlasLayoutInfo(se::Object* obj) { + auto* cls = se::Class::create("MipmapAtlasLayoutInfo", obj, nullptr, _SE(js_new_cc_MipmapAtlasLayoutInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("left", _SE(js_cc_MipmapAtlasLayoutInfo_left_get), _SE(js_cc_MipmapAtlasLayoutInfo_left_set)); + cls->defineProperty("top", _SE(js_cc_MipmapAtlasLayoutInfo_top_get), _SE(js_cc_MipmapAtlasLayoutInfo_top_set)); + cls->defineProperty("width", _SE(js_cc_MipmapAtlasLayoutInfo_width_get), _SE(js_cc_MipmapAtlasLayoutInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_MipmapAtlasLayoutInfo_height_get), _SE(js_cc_MipmapAtlasLayoutInfo_height_set)); + cls->defineProperty("level", _SE(js_cc_MipmapAtlasLayoutInfo_level_get), _SE(js_cc_MipmapAtlasLayoutInfo_level_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MipmapAtlasLayoutInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MipmapAtlasLayoutInfo_proto = cls->getProto(); + __jsb_cc_MipmapAtlasLayoutInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureCubeMipmapAtlasInfo_class = nullptr; +se::Object* __jsb_cc_TextureCubeMipmapAtlasInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureCubeMipmapAtlasInfo) + +static bool js_cc_TextureCubeMipmapAtlasInfo_atlas_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->atlas, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeMipmapAtlasInfo_atlas_set) + +static bool js_cc_TextureCubeMipmapAtlasInfo_atlas_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->atlas, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->atlas, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeMipmapAtlasInfo_atlas_get) + +static bool js_cc_TextureCubeMipmapAtlasInfo_layout_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layout, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeMipmapAtlasInfo_layout_set) + +static bool js_cc_TextureCubeMipmapAtlasInfo_layout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layout, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->layout, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeMipmapAtlasInfo_layout_get) + +static bool js_new_cc_TextureCubeMipmapAtlasInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureCubeMipmapAtlasInfo *result; + result = (cc::TextureCubeMipmapAtlasInfo *)new cc::TextureCubeMipmapAtlasInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureCubeMipmapAtlasInfo, __jsb_cc_TextureCubeMipmapAtlasInfo_class, js_delete_cc_TextureCubeMipmapAtlasInfo) + +static bool js_delete_cc_TextureCubeMipmapAtlasInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureCubeMipmapAtlasInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeMipmapAtlasInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("atlas", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->atlas), ctx); + } + + + json->getProperty("layout", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layout), ctx); + } + + + return ok; +} + + +bool js_register_cc_TextureCubeMipmapAtlasInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureCubeMipmapAtlasInfo", obj, nullptr, _SE(js_new_cc_TextureCubeMipmapAtlasInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("atlas", _SE(js_cc_TextureCubeMipmapAtlasInfo_atlas_get), _SE(js_cc_TextureCubeMipmapAtlasInfo_atlas_set)); + cls->defineProperty("layout", _SE(js_cc_TextureCubeMipmapAtlasInfo_layout_get), _SE(js_cc_TextureCubeMipmapAtlasInfo_layout_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureCubeMipmapAtlasInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureCubeMipmapAtlasInfo_proto = cls->getProto(); + __jsb_cc_TextureCubeMipmapAtlasInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureCubeSerializeData_class = nullptr; +se::Object* __jsb_cc_TextureCubeSerializeData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureCubeSerializeData) + +static bool js_cc_TextureCubeSerializeData_base_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->base, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_base_set) + +static bool js_cc_TextureCubeSerializeData_base_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->base, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->base, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_base_get) + +static bool js_cc_TextureCubeSerializeData_rgbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rgbe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_rgbe_set) + +static bool js_cc_TextureCubeSerializeData_rgbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rgbe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_rgbe_get) + +static bool js_cc_TextureCubeSerializeData_mipmapMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_mipmapMode_set) + +static bool js_cc_TextureCubeSerializeData_mipmapMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_mipmapMode_get) + +static bool js_cc_TextureCubeSerializeData_mipmaps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmaps, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_mipmaps_set) + +static bool js_cc_TextureCubeSerializeData_mipmaps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmaps, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmaps, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_mipmaps_get) + +static bool js_cc_TextureCubeSerializeData_mipmapAtlas_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapAtlas, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_mipmapAtlas_set) + +static bool js_cc_TextureCubeSerializeData_mipmapAtlas_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapAtlas, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapAtlas, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_mipmapAtlas_get) + +static bool js_new_cc_TextureCubeSerializeData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureCubeSerializeData *result; + result = (cc::TextureCubeSerializeData *)new cc::TextureCubeSerializeData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureCubeSerializeData, __jsb_cc_TextureCubeSerializeData_class, js_delete_cc_TextureCubeSerializeData) + +static bool js_delete_cc_TextureCubeSerializeData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureCubeSerializeData) + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeSerializeData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("base", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->base), ctx); + } + + + json->getProperty("rgbe", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rgbe), ctx); + } + + + json->getProperty("mipmapMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapMode), ctx); + } + + + json->getProperty("mipmaps", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmaps), ctx); + } + + + json->getProperty("mipmapAtlas", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapAtlas), ctx); + } + + + return ok; +} + + +bool js_register_cc_TextureCubeSerializeData(se::Object* obj) { + auto* cls = se::Class::create("TextureCubeSerializeData", obj, nullptr, _SE(js_new_cc_TextureCubeSerializeData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("base", _SE(js_cc_TextureCubeSerializeData_base_get), _SE(js_cc_TextureCubeSerializeData_base_set)); + cls->defineProperty("rgbe", _SE(js_cc_TextureCubeSerializeData_rgbe_get), _SE(js_cc_TextureCubeSerializeData_rgbe_set)); + cls->defineProperty("mipmapMode", _SE(js_cc_TextureCubeSerializeData_mipmapMode_get), _SE(js_cc_TextureCubeSerializeData_mipmapMode_set)); + cls->defineProperty("mipmaps", _SE(js_cc_TextureCubeSerializeData_mipmaps_get), _SE(js_cc_TextureCubeSerializeData_mipmaps_set)); + cls->defineProperty("mipmapAtlas", _SE(js_cc_TextureCubeSerializeData_mipmapAtlas_get), _SE(js_cc_TextureCubeSerializeData_mipmapAtlas_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureCubeSerializeData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureCubeSerializeData_proto = cls->getProto(); + __jsb_cc_TextureCubeSerializeData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureCube_class = nullptr; +se::Object* __jsb_cc_TextureCube_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureCube) + +static bool js_new_cc_TextureCube(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureCube *result; + result = (cc::TextureCube *)new cc::TextureCube(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureCube, __jsb_cc_TextureCube_class, js_delete_cc_TextureCube) + +static bool js_delete_cc_TextureCube(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureCube) + +static bool js_cc_TextureCube_fromTexture2DArray_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< cc::Texture2D * > *arg1 = 0 ; + ccstd::vector< cc::Texture2D * > temp1 ; + cc::TextureCube *result = 0 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::TextureCube *)cc::TextureCube::fromTexture2DArray((ccstd::vector< cc::Texture2D * > const &)*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_FUNC(js_cc_TextureCube_fromTexture2DArray_static) + +static bool js_cc_TextureCube_getMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + ccstd::vector< cc::ITextureCubeMipmap > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::ITextureCubeMipmap > *) &((cc::TextureCube const *)arg1)->getMipmaps(); + + 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_TextureCube_getMipmaps) + +static bool js_cc_TextureCube_getMipmapAtlas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::TextureCubeMipmapAtlasInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::TextureCubeMipmapAtlasInfo *) &((cc::TextureCube const *)arg1)->getMipmapAtlas(); + + 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_TextureCube_getMipmapAtlas) + +static bool js_cc_TextureCube_setMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + ccstd::vector< cc::ITextureCubeMipmap > *arg2 = 0 ; + ccstd::vector< cc::ITextureCubeMipmap > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmaps((ccstd::vector< cc::ITextureCubeMipmap > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmaps) + +static bool js_cc_TextureCube_setMipmapsForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + ccstd::vector< cc::ITextureCubeMipmap > *arg2 = 0 ; + ccstd::vector< cc::ITextureCubeMipmap > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapsForJS((ccstd::vector< cc::ITextureCubeMipmap > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmapsForJS) + +static bool js_cc_TextureCube_setMipmapAtlasForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::TextureCubeMipmapAtlasInfo *arg2 = 0 ; + cc::TextureCubeMipmapAtlasInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapAtlasForJS((cc::TextureCubeMipmapAtlasInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmapAtlasForJS) + +static bool js_cc_TextureCube_setMipmapAtlas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::TextureCubeMipmapAtlasInfo *arg2 = 0 ; + cc::TextureCubeMipmapAtlasInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapAtlas((cc::TextureCubeMipmapAtlasInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmapAtlas) + +static bool js_cc_TextureCube_getImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::ITextureCubeMipmap *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(s); + if (nullptr == arg1) return true; + result = (cc::ITextureCubeMipmap *)((cc::TextureCube const *)arg1)->getImage(); + + 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_TextureCube_getImage) + +static bool js_cc_TextureCube_setImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::ITextureCubeMipmap *arg2 = (cc::ITextureCubeMipmap *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setImage((cc::ITextureCubeMipmap const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setImage) + +static bool js_cc_TextureCube_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::ITextureCubeCreateInfo *arg2 = 0 ; + cc::ITextureCubeCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::ITextureCubeCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_reset) + +static bool js_cc_TextureCube_releaseTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->releaseTexture(); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_releaseTexture) + +static bool js_cc_TextureCube_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_initialize) + +static bool js_cc_TextureCube_getGfxTextureCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::gfx::TextureUsageBit arg2 ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + cc::gfx::TextureFlagBit arg5 ; + cc::gfx::TextureInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_getGfxTextureCreateInfo) + +static bool js_cc_TextureCube_getGfxTextureViewCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::gfx::TextureViewInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureViewCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_getGfxTextureViewCreateInfo) + +static bool js_cc_TextureCube__mipmapMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_mipmapMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCube__mipmapMode_set) + +static bool js_cc_TextureCube__mipmapMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_mipmapMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_mipmapMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCube__mipmapMode_get) + +static bool js_cc_TextureCube_isRGBE_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isRGBE); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCube_isRGBE_set) + +static bool js_cc_TextureCube_isRGBE_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isRGBE, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCube_isRGBE_get) + +bool js_register_cc_TextureCube(se::Object* obj) { + auto* cls = se::Class::create("TextureCube", obj, __jsb_cc_SimpleTexture_proto, _SE(js_new_cc_TextureCube)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_mipmapMode", _SE(js_cc_TextureCube__mipmapMode_get), _SE(js_cc_TextureCube__mipmapMode_set)); + cls->defineProperty("isRGBE", _SE(js_cc_TextureCube_isRGBE_get), _SE(js_cc_TextureCube_isRGBE_set)); + + cls->defineFunction("getMipmaps", _SE(js_cc_TextureCube_getMipmaps)); + cls->defineFunction("getMipmapAtlas", _SE(js_cc_TextureCube_getMipmapAtlas)); + cls->defineFunction("setMipmaps", _SE(js_cc_TextureCube_setMipmaps)); + cls->defineFunction("setMipmapsForJS", _SE(js_cc_TextureCube_setMipmapsForJS)); + cls->defineFunction("setMipmapAtlasForJS", _SE(js_cc_TextureCube_setMipmapAtlasForJS)); + cls->defineFunction("setMipmapAtlas", _SE(js_cc_TextureCube_setMipmapAtlas)); + cls->defineFunction("getImage", _SE(js_cc_TextureCube_getImage)); + cls->defineFunction("setImage", _SE(js_cc_TextureCube_setImage)); + cls->defineFunction("reset", _SE(js_cc_TextureCube_reset)); + cls->defineFunction("releaseTexture", _SE(js_cc_TextureCube_releaseTexture)); + cls->defineFunction("initialize", _SE(js_cc_TextureCube_initialize)); + cls->defineFunction("getGfxTextureCreateInfo", _SE(js_cc_TextureCube_getGfxTextureCreateInfo)); + cls->defineFunction("getGfxTextureViewCreateInfo", _SE(js_cc_TextureCube_getGfxTextureViewCreateInfo)); + + + cls->defineStaticFunction("fromTexture2DArray", _SE(js_cc_TextureCube_fromTexture2DArray_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureCube)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureCube_proto = cls->getProto(); + __jsb_cc_TextureCube_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IRenderTextureCreateInfo_class = nullptr; +se::Object* __jsb_cc_IRenderTextureCreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IRenderTextureCreateInfo) + +static bool js_cc_IRenderTextureCreateInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_name_set) + +static bool js_cc_IRenderTextureCreateInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_name_get) + +static bool js_cc_IRenderTextureCreateInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_width_set) + +static bool js_cc_IRenderTextureCreateInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_width_get) + +static bool js_cc_IRenderTextureCreateInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_height_set) + +static bool js_cc_IRenderTextureCreateInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_height_get) + +static bool js_cc_IRenderTextureCreateInfo_passInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_passInfo_set) + +static bool js_cc_IRenderTextureCreateInfo_passInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->passInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_passInfo_get) + +static bool js_cc_IRenderTextureCreateInfo_externalResLow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResLow, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_externalResLow_set) + +static bool js_cc_IRenderTextureCreateInfo_externalResLow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResLow, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResLow, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_externalResLow_get) + +static bool js_cc_IRenderTextureCreateInfo_externalResHigh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResHigh, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_externalResHigh_set) + +static bool js_cc_IRenderTextureCreateInfo_externalResHigh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResHigh, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResHigh, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_externalResHigh_get) + +static bool js_cc_IRenderTextureCreateInfo_externalFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalFlag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_externalFlag_set) + +static bool js_cc_IRenderTextureCreateInfo_externalFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalFlag, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalFlag, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_externalFlag_get) + +static bool js_new_cc_IRenderTextureCreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IRenderTextureCreateInfo *result; + result = (cc::IRenderTextureCreateInfo *)new cc::IRenderTextureCreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IRenderTextureCreateInfo, __jsb_cc_IRenderTextureCreateInfo_class, js_delete_cc_IRenderTextureCreateInfo) + +static bool js_delete_cc_IRenderTextureCreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IRenderTextureCreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IRenderTextureCreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("passInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passInfo), ctx); + } + + + json->getProperty("externalResLow", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResLow), ctx); + } + + + json->getProperty("externalResHigh", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResHigh), ctx); + } + + + json->getProperty("externalFlag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalFlag), ctx); + } + + + return ok; +} + + +bool js_register_cc_IRenderTextureCreateInfo(se::Object* obj) { + auto* cls = se::Class::create("IRenderTextureCreateInfo", obj, nullptr, _SE(js_new_cc_IRenderTextureCreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IRenderTextureCreateInfo_name_get), _SE(js_cc_IRenderTextureCreateInfo_name_set)); + cls->defineProperty("width", _SE(js_cc_IRenderTextureCreateInfo_width_get), _SE(js_cc_IRenderTextureCreateInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_IRenderTextureCreateInfo_height_get), _SE(js_cc_IRenderTextureCreateInfo_height_set)); + cls->defineProperty("passInfo", _SE(js_cc_IRenderTextureCreateInfo_passInfo_get), _SE(js_cc_IRenderTextureCreateInfo_passInfo_set)); + cls->defineProperty("externalResLow", _SE(js_cc_IRenderTextureCreateInfo_externalResLow_get), _SE(js_cc_IRenderTextureCreateInfo_externalResLow_set)); + cls->defineProperty("externalResHigh", _SE(js_cc_IRenderTextureCreateInfo_externalResHigh_get), _SE(js_cc_IRenderTextureCreateInfo_externalResHigh_set)); + cls->defineProperty("externalFlag", _SE(js_cc_IRenderTextureCreateInfo_externalFlag_get), _SE(js_cc_IRenderTextureCreateInfo_externalFlag_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IRenderTextureCreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IRenderTextureCreateInfo_proto = cls->getProto(); + __jsb_cc_IRenderTextureCreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderTexture_class = nullptr; +se::Object* __jsb_cc_RenderTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderTexture) + +static bool js_new_cc_RenderTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RenderTexture *result; + result = (cc::RenderTexture *)new cc::RenderTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RenderTexture, __jsb_cc_RenderTexture_class, js_delete_cc_RenderTexture) + +static bool js_delete_cc_RenderTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderTexture) + +static bool js_cc_RenderTexture_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::IRenderTextureCreateInfo *arg2 = 0 ; + cc::IRenderTextureCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::IRenderTextureCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_initialize) + +static bool js_cc_RenderTexture_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::IRenderTextureCreateInfo *arg2 = 0 ; + cc::IRenderTextureCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::IRenderTextureCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_reset) + +static bool js_cc_RenderTexture_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_resize) + +static bool js_cc_RenderTexture_initWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initWindow(); + + + return true; +} + +static bool js_cc_RenderTexture_initWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::IRenderTextureCreateInfo *arg2 = 0 ; + cc::IRenderTextureCreateInfo temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initWindow((cc::IRenderTextureCreateInfo const &)*arg2); + + + return true; +} + +static bool js_cc_RenderTexture_initWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_RenderTexture_initWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_RenderTexture_initWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_RenderTexture_initWindow) + +static bool js_cc_RenderTexture_readPixels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::vector< uint8_t > result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::RenderTexture const *)arg1)->readPixels(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_readPixels) + +static bool js_cc_RenderTexture_window_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_RenderTexture_window_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_RenderTexture_window_get) + +bool js_register_cc_RenderTexture(se::Object* obj) { + auto* cls = se::Class::create("RenderTexture", obj, __jsb_cc_TextureBase_proto, _SE(js_new_cc_RenderTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("window", _SE(js_cc_RenderTexture_window_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_RenderTexture_initialize)); + cls->defineFunction("reset", _SE(js_cc_RenderTexture_reset)); + cls->defineFunction("resize", _SE(js_cc_RenderTexture_resize)); + cls->defineFunction("initWindow", _SE(js_cc_RenderTexture_initWindow)); + cls->defineFunction("readPixels", _SE(js_cc_RenderTexture_readPixels)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderTexture_proto = cls->getProto(); + __jsb_cc_RenderTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BufferAsset_class = nullptr; +se::Object* __jsb_cc_BufferAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BufferAsset) + +static bool js_new_cc_BufferAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BufferAsset *result; + result = (cc::BufferAsset *)new cc::BufferAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BufferAsset, __jsb_cc_BufferAsset_class, js_delete_cc_BufferAsset) + +static bool js_delete_cc_BufferAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BufferAsset) + +static bool js_cc_BufferAsset_buffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BufferAsset *arg1 = (cc::BufferAsset *) NULL ; + cc::ArrayBuffer *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(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)((cc::BufferAsset const *)arg1)->getBuffer(); + + 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_BufferAsset_buffer) + +static bool js_cc_BufferAsset__nativeAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BufferAsset *arg1 = (cc::BufferAsset *) NULL ; + cc::ArrayBuffer *arg2 = (cc::ArrayBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_BufferAsset__nativeAsset_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_BufferAsset__nativeAsset_set) + +static bool js_cc_BufferAsset__nativeAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BufferAsset *arg1 = (cc::BufferAsset *) NULL ; + cc::ArrayBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)cc_BufferAsset__nativeAsset_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_BufferAsset__nativeAsset_get) + +bool js_register_cc_BufferAsset(se::Object* obj) { + auto* cls = se::Class::create("BufferAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_BufferAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_nativeAsset", _SE(js_cc_BufferAsset__nativeAsset_get), _SE(js_cc_BufferAsset__nativeAsset_set)); + + cls->defineFunction("buffer", _SE(js_cc_BufferAsset_buffer)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BufferAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BufferAsset_proto = cls->getProto(); + __jsb_cc_BufferAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IPropertyInfo_class = nullptr; +se::Object* __jsb_cc_IPropertyInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IPropertyInfo) + +static bool js_cc_IPropertyInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_type_set) + +static bool js_cc_IPropertyInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_type_get) + +static bool js_cc_IPropertyInfo_handleInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->handleInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_handleInfo_set) + +static bool js_cc_IPropertyInfo_handleInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->handleInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->handleInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_handleInfo_get) + +static bool js_cc_IPropertyInfo_samplerHash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerHash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_samplerHash_set) + +static bool js_cc_IPropertyInfo_samplerHash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerHash, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerHash, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_samplerHash_get) + +static bool js_cc_IPropertyInfo_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_value_set) + +static bool js_cc_IPropertyInfo_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->value, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_value_get) + +static bool js_cc_IPropertyInfo_linear_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linear, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_linear_set) + +static bool js_cc_IPropertyInfo_linear_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linear, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linear, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_linear_get) + +static bool js_cc_IPropertyInfo_editor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->editor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_editor_set) + +static bool js_cc_IPropertyInfo_editor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->editor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->editor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_editor_get) + +static bool js_new_cc_IPropertyInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IPropertyInfo *result; + result = (cc::IPropertyInfo *)new cc::IPropertyInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IPropertyInfo, __jsb_cc_IPropertyInfo_class, js_delete_cc_IPropertyInfo) + +static bool js_delete_cc_IPropertyInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IPropertyInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPropertyInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("handleInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->handleInfo), ctx); + } + + + json->getProperty("samplerHash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerHash), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + json->getProperty("linear", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linear), ctx); + } + + + json->getProperty("editor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->editor), ctx); + } + + + return ok; +} + + +bool js_register_cc_IPropertyInfo(se::Object* obj) { + auto* cls = se::Class::create("IPropertyInfo", obj, nullptr, _SE(js_new_cc_IPropertyInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_IPropertyInfo_type_get), _SE(js_cc_IPropertyInfo_type_set)); + cls->defineProperty("handleInfo", _SE(js_cc_IPropertyInfo_handleInfo_get), _SE(js_cc_IPropertyInfo_handleInfo_set)); + cls->defineProperty("samplerHash", _SE(js_cc_IPropertyInfo_samplerHash_get), _SE(js_cc_IPropertyInfo_samplerHash_set)); + cls->defineProperty("value", _SE(js_cc_IPropertyInfo_value_get), _SE(js_cc_IPropertyInfo_value_set)); + cls->defineProperty("linear", _SE(js_cc_IPropertyInfo_linear_get), _SE(js_cc_IPropertyInfo_linear_set)); + cls->defineProperty("editor", _SE(js_cc_IPropertyInfo_editor_get), _SE(js_cc_IPropertyInfo_editor_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IPropertyInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IPropertyInfo_proto = cls->getProto(); + __jsb_cc_IPropertyInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RasterizerStateInfo_class = nullptr; +se::Object* __jsb_cc_RasterizerStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RasterizerStateInfo) + +static bool js_cc_RasterizerStateInfo_isDiscard_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDiscard, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isDiscard_set) + +static bool js_cc_RasterizerStateInfo_isDiscard_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDiscard, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isDiscard, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isDiscard_get) + +static bool js_cc_RasterizerStateInfo_isFrontFaceCCW_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isFrontFaceCCW, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isFrontFaceCCW_set) + +static bool js_cc_RasterizerStateInfo_isFrontFaceCCW_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isFrontFaceCCW, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isFrontFaceCCW, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isFrontFaceCCW_get) + +static bool js_cc_RasterizerStateInfo_depthBiasEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasEnabled, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBiasEnabled_set) + +static bool js_cc_RasterizerStateInfo_depthBiasEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasEnabled, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBiasEnabled, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBiasEnabled_get) + +static bool js_cc_RasterizerStateInfo_isDepthClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDepthClip, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isDepthClip_set) + +static bool js_cc_RasterizerStateInfo_isDepthClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDepthClip, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isDepthClip, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isDepthClip_get) + +static bool js_cc_RasterizerStateInfo_isMultisample_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isMultisample, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isMultisample_set) + +static bool js_cc_RasterizerStateInfo_isMultisample_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isMultisample, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isMultisample, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isMultisample_get) + +static bool js_cc_RasterizerStateInfo_polygonMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->polygonMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_polygonMode_set) + +static bool js_cc_RasterizerStateInfo_polygonMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->polygonMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->polygonMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_polygonMode_get) + +static bool js_cc_RasterizerStateInfo_shadeModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadeModel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_shadeModel_set) + +static bool js_cc_RasterizerStateInfo_shadeModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadeModel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shadeModel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_shadeModel_get) + +static bool js_cc_RasterizerStateInfo_cullMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cullMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_cullMode_set) + +static bool js_cc_RasterizerStateInfo_cullMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cullMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cullMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_cullMode_get) + +static bool js_cc_RasterizerStateInfo_depthBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBias, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBias_set) + +static bool js_cc_RasterizerStateInfo_depthBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBias, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBias, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBias_get) + +static bool js_cc_RasterizerStateInfo_depthBiasClamp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasClamp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBiasClamp_set) + +static bool js_cc_RasterizerStateInfo_depthBiasClamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasClamp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBiasClamp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBiasClamp_get) + +static bool js_cc_RasterizerStateInfo_depthBiasSlop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasSlop, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBiasSlop_set) + +static bool js_cc_RasterizerStateInfo_depthBiasSlop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasSlop, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBiasSlop, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBiasSlop_get) + +static bool js_cc_RasterizerStateInfo_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_lineWidth_set) + +static bool js_cc_RasterizerStateInfo_lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lineWidth, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->lineWidth, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_lineWidth_get) + +static bool js_cc_RasterizerStateInfo_fromGFXRasterizerState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + cc::gfx::RasterizerState *arg2 = 0 ; + cc::gfx::RasterizerState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXRasterizerState((cc::gfx::RasterizerState const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RasterizerStateInfo_fromGFXRasterizerState) + +static bool js_cc_RasterizerStateInfo_assignToGFXRasterizerState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + cc::gfx::RasterizerState *arg2 = 0 ; + cc::gfx::RasterizerState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::RasterizerStateInfo const *)arg1)->assignToGFXRasterizerState(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RasterizerStateInfo_assignToGFXRasterizerState) + +static bool js_new_cc_RasterizerStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RasterizerStateInfo *result; + result = (cc::RasterizerStateInfo *)new cc::RasterizerStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RasterizerStateInfo, __jsb_cc_RasterizerStateInfo_class, js_delete_cc_RasterizerStateInfo) + +static bool js_delete_cc_RasterizerStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RasterizerStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::RasterizerStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isDiscard", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDiscard), ctx); + } + + + json->getProperty("isFrontFaceCCW", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isFrontFaceCCW), ctx); + } + + + json->getProperty("depthBiasEnabled", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasEnabled), ctx); + } + + + json->getProperty("isDepthClip", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDepthClip), ctx); + } + + + json->getProperty("isMultisample", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isMultisample), ctx); + } + + + json->getProperty("polygonMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->polygonMode), ctx); + } + + + json->getProperty("shadeModel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadeModel), ctx); + } + + + json->getProperty("cullMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cullMode), ctx); + } + + + json->getProperty("depthBias", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBias), ctx); + } + + + json->getProperty("depthBiasClamp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasClamp), ctx); + } + + + json->getProperty("depthBiasSlop", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasSlop), ctx); + } + + + json->getProperty("lineWidth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lineWidth), ctx); + } + + + return ok; +} + + +bool js_register_cc_RasterizerStateInfo(se::Object* obj) { + auto* cls = se::Class::create("RasterizerStateInfo", obj, nullptr, _SE(js_new_cc_RasterizerStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isDiscard", _SE(js_cc_RasterizerStateInfo_isDiscard_get), _SE(js_cc_RasterizerStateInfo_isDiscard_set)); + cls->defineProperty("isFrontFaceCCW", _SE(js_cc_RasterizerStateInfo_isFrontFaceCCW_get), _SE(js_cc_RasterizerStateInfo_isFrontFaceCCW_set)); + cls->defineProperty("depthBiasEnabled", _SE(js_cc_RasterizerStateInfo_depthBiasEnabled_get), _SE(js_cc_RasterizerStateInfo_depthBiasEnabled_set)); + cls->defineProperty("isDepthClip", _SE(js_cc_RasterizerStateInfo_isDepthClip_get), _SE(js_cc_RasterizerStateInfo_isDepthClip_set)); + cls->defineProperty("isMultisample", _SE(js_cc_RasterizerStateInfo_isMultisample_get), _SE(js_cc_RasterizerStateInfo_isMultisample_set)); + cls->defineProperty("polygonMode", _SE(js_cc_RasterizerStateInfo_polygonMode_get), _SE(js_cc_RasterizerStateInfo_polygonMode_set)); + cls->defineProperty("shadeModel", _SE(js_cc_RasterizerStateInfo_shadeModel_get), _SE(js_cc_RasterizerStateInfo_shadeModel_set)); + cls->defineProperty("cullMode", _SE(js_cc_RasterizerStateInfo_cullMode_get), _SE(js_cc_RasterizerStateInfo_cullMode_set)); + cls->defineProperty("depthBias", _SE(js_cc_RasterizerStateInfo_depthBias_get), _SE(js_cc_RasterizerStateInfo_depthBias_set)); + cls->defineProperty("depthBiasClamp", _SE(js_cc_RasterizerStateInfo_depthBiasClamp_get), _SE(js_cc_RasterizerStateInfo_depthBiasClamp_set)); + cls->defineProperty("depthBiasSlop", _SE(js_cc_RasterizerStateInfo_depthBiasSlop_get), _SE(js_cc_RasterizerStateInfo_depthBiasSlop_set)); + cls->defineProperty("lineWidth", _SE(js_cc_RasterizerStateInfo_lineWidth_get), _SE(js_cc_RasterizerStateInfo_lineWidth_set)); + + cls->defineFunction("fromGFXRasterizerState", _SE(js_cc_RasterizerStateInfo_fromGFXRasterizerState)); + cls->defineFunction("assignToGFXRasterizerState", _SE(js_cc_RasterizerStateInfo_assignToGFXRasterizerState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RasterizerStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RasterizerStateInfo_proto = cls->getProto(); + __jsb_cc_RasterizerStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_DepthStencilStateInfo_class = nullptr; +se::Object* __jsb_cc_DepthStencilStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DepthStencilStateInfo) + +static bool js_cc_DepthStencilStateInfo_depthTest_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthTest, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_depthTest_set) + +static bool js_cc_DepthStencilStateInfo_depthTest_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthTest, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthTest, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_depthTest_get) + +static bool js_cc_DepthStencilStateInfo_depthWrite_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthWrite, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_depthWrite_set) + +static bool js_cc_DepthStencilStateInfo_depthWrite_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthWrite, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthWrite, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_depthWrite_get) + +static bool js_cc_DepthStencilStateInfo_stencilTestFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilTestFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilTestFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilTestFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilTestFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilTestBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilTestBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilTestBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilTestBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilTestBack_get) + +static bool js_cc_DepthStencilStateInfo_depthFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_depthFunc_set) + +static bool js_cc_DepthStencilStateInfo_depthFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_depthFunc_get) + +static bool js_cc_DepthStencilStateInfo_stencilFuncFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFuncFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilFuncFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFuncFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilReadMaskFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilReadMaskFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilReadMaskFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilWriteMaskFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFailOpFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFailOpFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilZFailOpFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilZFailOpFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilPassOpFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilPassOpFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilRefFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilRefFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilRefFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilRefFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilRefFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilFuncBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFuncBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilFuncBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFuncBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilReadMaskBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilReadMaskBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilReadMaskBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilWriteMaskBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFailOpBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFailOpBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilZFailOpBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilZFailOpBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilPassOpBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilPassOpBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilRefBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilRefBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilRefBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilRefBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilRefBack_get) + +static bool js_cc_DepthStencilStateInfo_fromGFXDepthStencilState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + cc::gfx::DepthStencilState *arg2 = 0 ; + cc::gfx::DepthStencilState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXDepthStencilState((cc::gfx::DepthStencilState const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_DepthStencilStateInfo_fromGFXDepthStencilState) + +static bool js_cc_DepthStencilStateInfo_assignToGFXDepthStencilState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + cc::gfx::DepthStencilState *arg2 = 0 ; + cc::gfx::DepthStencilState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::DepthStencilStateInfo const *)arg1)->assignToGFXDepthStencilState(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_DepthStencilStateInfo_assignToGFXDepthStencilState) + +static bool js_new_cc_DepthStencilStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DepthStencilStateInfo *result; + result = (cc::DepthStencilStateInfo *)new cc::DepthStencilStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DepthStencilStateInfo, __jsb_cc_DepthStencilStateInfo_class, js_delete_cc_DepthStencilStateInfo) + +static bool js_delete_cc_DepthStencilStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DepthStencilStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::DepthStencilStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("depthTest", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthTest), ctx); + } + + + json->getProperty("depthWrite", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthWrite), ctx); + } + + + json->getProperty("stencilTestFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestFront), ctx); + } + + + json->getProperty("stencilTestBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestBack), ctx); + } + + + json->getProperty("depthFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthFunc), ctx); + } + + + json->getProperty("stencilFuncFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncFront), ctx); + } + + + json->getProperty("stencilReadMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskFront), ctx); + } + + + json->getProperty("stencilWriteMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskFront), ctx); + } + + + json->getProperty("stencilFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpFront), ctx); + } + + + json->getProperty("stencilZFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpFront), ctx); + } + + + json->getProperty("stencilPassOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpFront), ctx); + } + + + json->getProperty("stencilRefFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefFront), ctx); + } + + + json->getProperty("stencilFuncBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncBack), ctx); + } + + + json->getProperty("stencilReadMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskBack), ctx); + } + + + json->getProperty("stencilWriteMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskBack), ctx); + } + + + json->getProperty("stencilFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpBack), ctx); + } + + + json->getProperty("stencilZFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpBack), ctx); + } + + + json->getProperty("stencilPassOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpBack), ctx); + } + + + json->getProperty("stencilRefBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefBack), ctx); + } + + + return ok; +} + + +bool js_register_cc_DepthStencilStateInfo(se::Object* obj) { + auto* cls = se::Class::create("DepthStencilStateInfo", obj, nullptr, _SE(js_new_cc_DepthStencilStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("depthTest", _SE(js_cc_DepthStencilStateInfo_depthTest_get), _SE(js_cc_DepthStencilStateInfo_depthTest_set)); + cls->defineProperty("depthWrite", _SE(js_cc_DepthStencilStateInfo_depthWrite_get), _SE(js_cc_DepthStencilStateInfo_depthWrite_set)); + cls->defineProperty("stencilTestFront", _SE(js_cc_DepthStencilStateInfo_stencilTestFront_get), _SE(js_cc_DepthStencilStateInfo_stencilTestFront_set)); + cls->defineProperty("stencilTestBack", _SE(js_cc_DepthStencilStateInfo_stencilTestBack_get), _SE(js_cc_DepthStencilStateInfo_stencilTestBack_set)); + cls->defineProperty("depthFunc", _SE(js_cc_DepthStencilStateInfo_depthFunc_get), _SE(js_cc_DepthStencilStateInfo_depthFunc_set)); + cls->defineProperty("stencilFuncFront", _SE(js_cc_DepthStencilStateInfo_stencilFuncFront_get), _SE(js_cc_DepthStencilStateInfo_stencilFuncFront_set)); + cls->defineProperty("stencilReadMaskFront", _SE(js_cc_DepthStencilStateInfo_stencilReadMaskFront_get), _SE(js_cc_DepthStencilStateInfo_stencilReadMaskFront_set)); + cls->defineProperty("stencilWriteMaskFront", _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_get), _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_set)); + cls->defineProperty("stencilFailOpFront", _SE(js_cc_DepthStencilStateInfo_stencilFailOpFront_get), _SE(js_cc_DepthStencilStateInfo_stencilFailOpFront_set)); + cls->defineProperty("stencilZFailOpFront", _SE(js_cc_DepthStencilStateInfo_stencilZFailOpFront_get), _SE(js_cc_DepthStencilStateInfo_stencilZFailOpFront_set)); + cls->defineProperty("stencilPassOpFront", _SE(js_cc_DepthStencilStateInfo_stencilPassOpFront_get), _SE(js_cc_DepthStencilStateInfo_stencilPassOpFront_set)); + cls->defineProperty("stencilRefFront", _SE(js_cc_DepthStencilStateInfo_stencilRefFront_get), _SE(js_cc_DepthStencilStateInfo_stencilRefFront_set)); + cls->defineProperty("stencilFuncBack", _SE(js_cc_DepthStencilStateInfo_stencilFuncBack_get), _SE(js_cc_DepthStencilStateInfo_stencilFuncBack_set)); + cls->defineProperty("stencilReadMaskBack", _SE(js_cc_DepthStencilStateInfo_stencilReadMaskBack_get), _SE(js_cc_DepthStencilStateInfo_stencilReadMaskBack_set)); + cls->defineProperty("stencilWriteMaskBack", _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_get), _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_set)); + cls->defineProperty("stencilFailOpBack", _SE(js_cc_DepthStencilStateInfo_stencilFailOpBack_get), _SE(js_cc_DepthStencilStateInfo_stencilFailOpBack_set)); + cls->defineProperty("stencilZFailOpBack", _SE(js_cc_DepthStencilStateInfo_stencilZFailOpBack_get), _SE(js_cc_DepthStencilStateInfo_stencilZFailOpBack_set)); + cls->defineProperty("stencilPassOpBack", _SE(js_cc_DepthStencilStateInfo_stencilPassOpBack_get), _SE(js_cc_DepthStencilStateInfo_stencilPassOpBack_set)); + cls->defineProperty("stencilRefBack", _SE(js_cc_DepthStencilStateInfo_stencilRefBack_get), _SE(js_cc_DepthStencilStateInfo_stencilRefBack_set)); + + cls->defineFunction("fromGFXDepthStencilState", _SE(js_cc_DepthStencilStateInfo_fromGFXDepthStencilState)); + cls->defineFunction("assignToGFXDepthStencilState", _SE(js_cc_DepthStencilStateInfo_assignToGFXDepthStencilState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DepthStencilStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DepthStencilStateInfo_proto = cls->getProto(); + __jsb_cc_DepthStencilStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BlendTargetInfo_class = nullptr; +se::Object* __jsb_cc_BlendTargetInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BlendTargetInfo) + +static bool js_cc_BlendTargetInfo_blend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blend_set) + +static bool js_cc_BlendTargetInfo_blend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blend, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blend, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blend_get) + +static bool js_cc_BlendTargetInfo_blendSrc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendSrc_set) + +static bool js_cc_BlendTargetInfo_blendSrc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendSrc_get) + +static bool js_cc_BlendTargetInfo_blendDst_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDst, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendDst_set) + +static bool js_cc_BlendTargetInfo_blendDst_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDst, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDst, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendDst_get) + +static bool js_cc_BlendTargetInfo_blendEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendEq_set) + +static bool js_cc_BlendTargetInfo_blendEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendEq_get) + +static bool js_cc_BlendTargetInfo_blendSrcAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrcAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendSrcAlpha_set) + +static bool js_cc_BlendTargetInfo_blendSrcAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrcAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrcAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendSrcAlpha_get) + +static bool js_cc_BlendTargetInfo_blendDstAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDstAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendDstAlpha_set) + +static bool js_cc_BlendTargetInfo_blendDstAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDstAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDstAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendDstAlpha_get) + +static bool js_cc_BlendTargetInfo_blendAlphaEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendAlphaEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendAlphaEq_set) + +static bool js_cc_BlendTargetInfo_blendAlphaEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendAlphaEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendAlphaEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendAlphaEq_get) + +static bool js_cc_BlendTargetInfo_blendColorMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColorMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendColorMask_set) + +static bool js_cc_BlendTargetInfo_blendColorMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColorMask, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColorMask, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendColorMask_get) + +static bool js_cc_BlendTargetInfo_fromGFXBlendTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + cc::gfx::BlendTarget *arg2 = 0 ; + cc::gfx::BlendTarget temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXBlendTarget((cc::gfx::BlendTarget const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendTargetInfo_fromGFXBlendTarget) + +static bool js_cc_BlendTargetInfo_assignToGFXBlendTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + cc::gfx::BlendTarget *arg2 = 0 ; + cc::gfx::BlendTarget temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::BlendTargetInfo const *)arg1)->assignToGFXBlendTarget(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendTargetInfo_assignToGFXBlendTarget) + +static bool js_new_cc_BlendTargetInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BlendTargetInfo *result; + result = (cc::BlendTargetInfo *)new cc::BlendTargetInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BlendTargetInfo, __jsb_cc_BlendTargetInfo_class, js_delete_cc_BlendTargetInfo) + +static bool js_delete_cc_BlendTargetInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BlendTargetInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendTargetInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("blend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blend), ctx); + } + + + json->getProperty("blendSrc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrc), ctx); + } + + + json->getProperty("blendDst", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDst), ctx); + } + + + json->getProperty("blendEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendEq), ctx); + } + + + json->getProperty("blendSrcAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrcAlpha), ctx); + } + + + json->getProperty("blendDstAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDstAlpha), ctx); + } + + + json->getProperty("blendAlphaEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendAlphaEq), ctx); + } + + + json->getProperty("blendColorMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColorMask), ctx); + } + + + return ok; +} + + +bool js_register_cc_BlendTargetInfo(se::Object* obj) { + auto* cls = se::Class::create("BlendTargetInfo", obj, nullptr, _SE(js_new_cc_BlendTargetInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("blend", _SE(js_cc_BlendTargetInfo_blend_get), _SE(js_cc_BlendTargetInfo_blend_set)); + cls->defineProperty("blendSrc", _SE(js_cc_BlendTargetInfo_blendSrc_get), _SE(js_cc_BlendTargetInfo_blendSrc_set)); + cls->defineProperty("blendDst", _SE(js_cc_BlendTargetInfo_blendDst_get), _SE(js_cc_BlendTargetInfo_blendDst_set)); + cls->defineProperty("blendEq", _SE(js_cc_BlendTargetInfo_blendEq_get), _SE(js_cc_BlendTargetInfo_blendEq_set)); + cls->defineProperty("blendSrcAlpha", _SE(js_cc_BlendTargetInfo_blendSrcAlpha_get), _SE(js_cc_BlendTargetInfo_blendSrcAlpha_set)); + cls->defineProperty("blendDstAlpha", _SE(js_cc_BlendTargetInfo_blendDstAlpha_get), _SE(js_cc_BlendTargetInfo_blendDstAlpha_set)); + cls->defineProperty("blendAlphaEq", _SE(js_cc_BlendTargetInfo_blendAlphaEq_get), _SE(js_cc_BlendTargetInfo_blendAlphaEq_set)); + cls->defineProperty("blendColorMask", _SE(js_cc_BlendTargetInfo_blendColorMask_get), _SE(js_cc_BlendTargetInfo_blendColorMask_set)); + + cls->defineFunction("fromGFXBlendTarget", _SE(js_cc_BlendTargetInfo_fromGFXBlendTarget)); + cls->defineFunction("assignToGFXBlendTarget", _SE(js_cc_BlendTargetInfo_assignToGFXBlendTarget)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BlendTargetInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BlendTargetInfo_proto = cls->getProto(); + __jsb_cc_BlendTargetInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BlendStateInfo_class = nullptr; +se::Object* __jsb_cc_BlendStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BlendStateInfo) + +static bool js_cc_BlendStateInfo_isA2C_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isA2C, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_isA2C_set) + +static bool js_cc_BlendStateInfo_isA2C_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isA2C, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isA2C, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_isA2C_get) + +static bool js_cc_BlendStateInfo_isIndepend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isIndepend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_isIndepend_set) + +static bool js_cc_BlendStateInfo_isIndepend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isIndepend, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isIndepend, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_isIndepend_get) + +static bool js_cc_BlendStateInfo_blendColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_blendColor_set) + +static bool js_cc_BlendStateInfo_blendColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_blendColor_get) + +static bool js_cc_BlendStateInfo_targets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_targets_set) + +static bool js_cc_BlendStateInfo_targets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targets, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targets, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_targets_get) + +static bool js_cc_BlendStateInfo_fromGFXBlendState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + cc::gfx::BlendState *arg2 = 0 ; + cc::gfx::BlendState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXBlendState((cc::gfx::BlendState const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendStateInfo_fromGFXBlendState) + +static bool js_cc_BlendStateInfo_assignToGFXBlendState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + cc::gfx::BlendState *arg2 = 0 ; + cc::gfx::BlendState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::BlendStateInfo const *)arg1)->assignToGFXBlendState(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendStateInfo_assignToGFXBlendState) + +static bool js_new_cc_BlendStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BlendStateInfo *result; + result = (cc::BlendStateInfo *)new cc::BlendStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BlendStateInfo, __jsb_cc_BlendStateInfo_class, js_delete_cc_BlendStateInfo) + +static bool js_delete_cc_BlendStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BlendStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isA2C", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isA2C), ctx); + } + + + json->getProperty("isIndepend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isIndepend), ctx); + } + + + json->getProperty("blendColor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColor), ctx); + } + + + json->getProperty("targets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targets), ctx); + } + + + return ok; +} + + +bool js_register_cc_BlendStateInfo(se::Object* obj) { + auto* cls = se::Class::create("BlendStateInfo", obj, nullptr, _SE(js_new_cc_BlendStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isA2C", _SE(js_cc_BlendStateInfo_isA2C_get), _SE(js_cc_BlendStateInfo_isA2C_set)); + cls->defineProperty("isIndepend", _SE(js_cc_BlendStateInfo_isIndepend_get), _SE(js_cc_BlendStateInfo_isIndepend_set)); + cls->defineProperty("blendColor", _SE(js_cc_BlendStateInfo_blendColor_get), _SE(js_cc_BlendStateInfo_blendColor_set)); + cls->defineProperty("targets", _SE(js_cc_BlendStateInfo_targets_get), _SE(js_cc_BlendStateInfo_targets_set)); + + cls->defineFunction("fromGFXBlendState", _SE(js_cc_BlendStateInfo_fromGFXBlendState)); + cls->defineFunction("assignToGFXBlendState", _SE(js_cc_BlendStateInfo_assignToGFXBlendState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BlendStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BlendStateInfo_proto = cls->getProto(); + __jsb_cc_BlendStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IPassStates_class = nullptr; +se::Object* __jsb_cc_IPassStates_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IPassStates) + +static bool js_cc_IPassStates_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_priority_set) + +static bool js_cc_IPassStates_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->priority, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_priority_get) + +static bool js_cc_IPassStates_primitive_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitive, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_primitive_set) + +static bool js_cc_IPassStates_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitive, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitive, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_primitive_get) + +static bool js_cc_IPassStates_stage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_stage_set) + +static bool js_cc_IPassStates_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_stage_get) + +static bool js_cc_IPassStates_rasterizerState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rasterizerState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_rasterizerState_set) + +static bool js_cc_IPassStates_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rasterizerState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rasterizerState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_rasterizerState_get) + +static bool js_cc_IPassStates_depthStencilState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_depthStencilState_set) + +static bool js_cc_IPassStates_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_depthStencilState_get) + +static bool js_cc_IPassStates_blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_blendState_set) + +static bool js_cc_IPassStates_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_blendState_get) + +static bool js_cc_IPassStates_dynamicStates_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamicStates, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_dynamicStates_set) + +static bool js_cc_IPassStates_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamicStates, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamicStates, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_dynamicStates_get) + +static bool js_cc_IPassStates_phase_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->phase, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_phase_set) + +static bool js_cc_IPassStates_phase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->phase, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->phase, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_phase_get) + +static bool js_cc_IPassStates_pass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_pass_set) + +static bool js_cc_IPassStates_pass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_pass_get) + +static bool js_cc_IPassStates_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_subpass_set) + +static bool js_cc_IPassStates_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_subpass_get) + +static bool js_new_cc_IPassStates__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassStates *result; + result = (cc::IPassStates *)new cc::IPassStates(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassStates__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = 0 ; + cc::IPassInfoFull temp1 ; + cc::IPassStates *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::IPassStates *)new cc::IPassStates((cc::IPassInfoFull const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassStates(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_IPassStates__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_IPassStates__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of IPassStates"); + return false; +} +SE_BIND_CTOR(js_new_cc_IPassStates, __jsb_cc_IPassStates_class, js_delete_cc_IPassStates) + +static bool js_cc_IPassStates_overrides(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + cc::IPassInfoFull *arg2 = 0 ; + cc::IPassInfoFull temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->overrides((cc::IPassInfoFull const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_IPassStates_overrides) + +static bool js_delete_cc_IPassStates(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IPassStates) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassStates * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("primitive", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitive), ctx); + } + + + json->getProperty("stage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stage), ctx); + } + + + json->getProperty("rasterizerState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rasterizerState), ctx); + } + + + json->getProperty("depthStencilState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilState), ctx); + } + + + json->getProperty("blendState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendState), ctx); + } + + + json->getProperty("dynamicStates", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamicStates), ctx); + } + + + json->getProperty("phase", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->phase), ctx); + } + + + json->getProperty("pass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pass), ctx); + } + + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + return ok; +} + + +bool js_register_cc_IPassStates(se::Object* obj) { + auto* cls = se::Class::create("IPassStates", obj, nullptr, _SE(js_new_cc_IPassStates)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("priority", _SE(js_cc_IPassStates_priority_get), _SE(js_cc_IPassStates_priority_set)); + cls->defineProperty("primitive", _SE(js_cc_IPassStates_primitive_get), _SE(js_cc_IPassStates_primitive_set)); + cls->defineProperty("stage", _SE(js_cc_IPassStates_stage_get), _SE(js_cc_IPassStates_stage_set)); + cls->defineProperty("rasterizerState", _SE(js_cc_IPassStates_rasterizerState_get), _SE(js_cc_IPassStates_rasterizerState_set)); + cls->defineProperty("depthStencilState", _SE(js_cc_IPassStates_depthStencilState_get), _SE(js_cc_IPassStates_depthStencilState_set)); + cls->defineProperty("blendState", _SE(js_cc_IPassStates_blendState_get), _SE(js_cc_IPassStates_blendState_set)); + cls->defineProperty("dynamicStates", _SE(js_cc_IPassStates_dynamicStates_get), _SE(js_cc_IPassStates_dynamicStates_set)); + cls->defineProperty("phase", _SE(js_cc_IPassStates_phase_get), _SE(js_cc_IPassStates_phase_set)); + cls->defineProperty("pass", _SE(js_cc_IPassStates_pass_get), _SE(js_cc_IPassStates_pass_set)); + cls->defineProperty("subpass", _SE(js_cc_IPassStates_subpass_get), _SE(js_cc_IPassStates_subpass_set)); + + cls->defineFunction("overrides", _SE(js_cc_IPassStates_overrides)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IPassStates)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IPassStates_proto = cls->getProto(); + __jsb_cc_IPassStates_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IPassInfoFull_class = nullptr; +se::Object* __jsb_cc_IPassInfoFull_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IPassInfoFull) + +static bool js_cc_IPassInfoFull_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_priority_set) + +static bool js_cc_IPassInfoFull_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->priority, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_priority_get) + +static bool js_cc_IPassInfoFull_primitive_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitive, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_primitive_set) + +static bool js_cc_IPassInfoFull_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitive, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitive, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_primitive_get) + +static bool js_cc_IPassInfoFull_stage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_stage_set) + +static bool js_cc_IPassInfoFull_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_stage_get) + +static bool js_cc_IPassInfoFull_rasterizerState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rasterizerState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_rasterizerState_set) + +static bool js_cc_IPassInfoFull_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rasterizerState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rasterizerState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_rasterizerState_get) + +static bool js_cc_IPassInfoFull_depthStencilState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_depthStencilState_set) + +static bool js_cc_IPassInfoFull_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_depthStencilState_get) + +static bool js_cc_IPassInfoFull_blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_blendState_set) + +static bool js_cc_IPassInfoFull_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_blendState_get) + +static bool js_cc_IPassInfoFull_dynamicStates_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamicStates, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_dynamicStates_set) + +static bool js_cc_IPassInfoFull_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamicStates, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamicStates, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_dynamicStates_get) + +static bool js_cc_IPassInfoFull_phase_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->phase, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_phase_set) + +static bool js_cc_IPassInfoFull_phase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->phase, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->phase, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_phase_get) + +static bool js_cc_IPassInfoFull_pass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_pass_set) + +static bool js_cc_IPassInfoFull_pass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_pass_get) + +static bool js_cc_IPassInfoFull_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_subpass_set) + +static bool js_cc_IPassInfoFull_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_subpass_get) + +static bool js_cc_IPassInfoFull_program_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->program, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_program_set) + +static bool js_cc_IPassInfoFull_program_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->program, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->program, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_program_get) + +static bool js_cc_IPassInfoFull_embeddedMacros_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->embeddedMacros, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_embeddedMacros_set) + +static bool js_cc_IPassInfoFull_embeddedMacros_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->embeddedMacros, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->embeddedMacros, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_embeddedMacros_get) + +static bool js_cc_IPassInfoFull_propertyIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->propertyIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_propertyIndex_set) + +static bool js_cc_IPassInfoFull_propertyIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->propertyIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->propertyIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_propertyIndex_get) + +static bool js_cc_IPassInfoFull_cpp_keyword_switch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->switch_, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_cpp_keyword_switch_set) + +static bool js_cc_IPassInfoFull_cpp_keyword_switch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->switch_, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->switch_, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_cpp_keyword_switch_get) + +static bool js_cc_IPassInfoFull_properties_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->properties, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_properties_set) + +static bool js_cc_IPassInfoFull_properties_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->properties, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->properties, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_properties_get) + +static bool js_cc_IPassInfoFull_passIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_passIndex_set) + +static bool js_cc_IPassInfoFull_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_passIndex_get) + +static bool js_cc_IPassInfoFull_subpassID_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassID, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_subpassID_set) + +static bool js_cc_IPassInfoFull_subpassID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassID, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_subpassID_get) + +static bool js_cc_IPassInfoFull_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_defines_set) + +static bool js_cc_IPassInfoFull_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_defines_get) + +static bool js_cc_IPassInfoFull_stateOverrides_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stateOverrides, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_stateOverrides_set) + +static bool js_cc_IPassInfoFull_stateOverrides_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stateOverrides, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stateOverrides, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_stateOverrides_get) + +static bool js_new_cc_IPassInfoFull__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassInfoFull *result; + result = (cc::IPassInfoFull *)new cc::IPassInfoFull(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassInfoFull__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = 0 ; + cc::IPassStates temp1 ; + cc::IPassInfoFull *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::IPassInfoFull *)new cc::IPassInfoFull((cc::IPassStates const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassInfoFull(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_IPassInfoFull__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_IPassInfoFull__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of IPassInfoFull"); + return false; +} +SE_BIND_CTOR(js_new_cc_IPassInfoFull, __jsb_cc_IPassInfoFull_class, js_delete_cc_IPassInfoFull) + +static bool js_delete_cc_IPassInfoFull(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IPassInfoFull) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassInfoFull * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("primitive", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitive), ctx); + } + + + json->getProperty("stage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stage), ctx); + } + + + json->getProperty("rasterizerState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rasterizerState), ctx); + } + + + json->getProperty("depthStencilState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilState), ctx); + } + + + json->getProperty("blendState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendState), ctx); + } + + + json->getProperty("dynamicStates", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamicStates), ctx); + } + + + json->getProperty("phase", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->phase), ctx); + } + + + json->getProperty("pass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pass), ctx); + } + + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + json->getProperty("program", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->program), ctx); + } + + + json->getProperty("embeddedMacros", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->embeddedMacros), ctx); + } + + + json->getProperty("propertyIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->propertyIndex), ctx); + } + + + json->getProperty("switch", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->switch_), ctx); + } + + + json->getProperty("properties", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->properties), ctx); + } + + + json->getProperty("passIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passIndex), ctx); + } + + + json->getProperty("subpassID", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassID), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("stateOverrides", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stateOverrides), ctx); + } + + + return ok; +} + + +bool js_register_cc_IPassInfoFull(se::Object* obj) { + auto* cls = se::Class::create("IPassInfoFull", obj, nullptr, _SE(js_new_cc_IPassInfoFull)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("priority", _SE(js_cc_IPassInfoFull_priority_get), _SE(js_cc_IPassInfoFull_priority_set)); + cls->defineProperty("primitive", _SE(js_cc_IPassInfoFull_primitive_get), _SE(js_cc_IPassInfoFull_primitive_set)); + cls->defineProperty("stage", _SE(js_cc_IPassInfoFull_stage_get), _SE(js_cc_IPassInfoFull_stage_set)); + cls->defineProperty("rasterizerState", _SE(js_cc_IPassInfoFull_rasterizerState_get), _SE(js_cc_IPassInfoFull_rasterizerState_set)); + cls->defineProperty("depthStencilState", _SE(js_cc_IPassInfoFull_depthStencilState_get), _SE(js_cc_IPassInfoFull_depthStencilState_set)); + cls->defineProperty("blendState", _SE(js_cc_IPassInfoFull_blendState_get), _SE(js_cc_IPassInfoFull_blendState_set)); + cls->defineProperty("dynamicStates", _SE(js_cc_IPassInfoFull_dynamicStates_get), _SE(js_cc_IPassInfoFull_dynamicStates_set)); + cls->defineProperty("phase", _SE(js_cc_IPassInfoFull_phase_get), _SE(js_cc_IPassInfoFull_phase_set)); + cls->defineProperty("pass", _SE(js_cc_IPassInfoFull_pass_get), _SE(js_cc_IPassInfoFull_pass_set)); + cls->defineProperty("subpass", _SE(js_cc_IPassInfoFull_subpass_get), _SE(js_cc_IPassInfoFull_subpass_set)); + cls->defineProperty("program", _SE(js_cc_IPassInfoFull_program_get), _SE(js_cc_IPassInfoFull_program_set)); + cls->defineProperty("embeddedMacros", _SE(js_cc_IPassInfoFull_embeddedMacros_get), _SE(js_cc_IPassInfoFull_embeddedMacros_set)); + cls->defineProperty("propertyIndex", _SE(js_cc_IPassInfoFull_propertyIndex_get), _SE(js_cc_IPassInfoFull_propertyIndex_set)); + cls->defineProperty("switch", _SE(js_cc_IPassInfoFull_cpp_keyword_switch_get), _SE(js_cc_IPassInfoFull_cpp_keyword_switch_set)); + cls->defineProperty("properties", _SE(js_cc_IPassInfoFull_properties_get), _SE(js_cc_IPassInfoFull_properties_set)); + cls->defineProperty("passIndex", _SE(js_cc_IPassInfoFull_passIndex_get), _SE(js_cc_IPassInfoFull_passIndex_set)); + cls->defineProperty("subpassID", _SE(js_cc_IPassInfoFull_subpassID_get), _SE(js_cc_IPassInfoFull_subpassID_set)); + cls->defineProperty("defines", _SE(js_cc_IPassInfoFull_defines_get), _SE(js_cc_IPassInfoFull_defines_set)); + cls->defineProperty("stateOverrides", _SE(js_cc_IPassInfoFull_stateOverrides_get), _SE(js_cc_IPassInfoFull_stateOverrides_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IPassInfoFull)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IPassInfoFull_proto = cls->getProto(); + __jsb_cc_IPassInfoFull_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITechniqueInfo_class = nullptr; +se::Object* __jsb_cc_ITechniqueInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITechniqueInfo) + +static bool js_cc_ITechniqueInfo_passes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITechniqueInfo_passes_set) + +static bool js_cc_ITechniqueInfo_passes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->passes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITechniqueInfo_passes_get) + +static bool js_cc_ITechniqueInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITechniqueInfo_name_set) + +static bool js_cc_ITechniqueInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITechniqueInfo_name_get) + +static bool js_new_cc_ITechniqueInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITechniqueInfo *result; + result = (cc::ITechniqueInfo *)new cc::ITechniqueInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITechniqueInfo, __jsb_cc_ITechniqueInfo_class, js_delete_cc_ITechniqueInfo) + +static bool js_delete_cc_ITechniqueInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITechniqueInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITechniqueInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("passes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passes), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITechniqueInfo(se::Object* obj) { + auto* cls = se::Class::create("ITechniqueInfo", obj, nullptr, _SE(js_new_cc_ITechniqueInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("passes", _SE(js_cc_ITechniqueInfo_passes_get), _SE(js_cc_ITechniqueInfo_passes_set)); + cls->defineProperty("name", _SE(js_cc_ITechniqueInfo_name_get), _SE(js_cc_ITechniqueInfo_name_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITechniqueInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITechniqueInfo_proto = cls->getProto(); + __jsb_cc_ITechniqueInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBlockInfo_class = nullptr; +se::Object* __jsb_cc_IBlockInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBlockInfo) + +static bool js_cc_IBlockInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_binding_set) + +static bool js_cc_IBlockInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_binding_get) + +static bool js_cc_IBlockInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_name_set) + +static bool js_cc_IBlockInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_name_get) + +static bool js_cc_IBlockInfo_members_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->members, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_members_set) + +static bool js_cc_IBlockInfo_members_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->members, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->members, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_members_get) + +static bool js_cc_IBlockInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_stageFlags_set) + +static bool js_cc_IBlockInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_stageFlags_get) + +static bool js_cc_IBlockInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_defines_set) + +static bool js_cc_IBlockInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_defines_get) + +static bool js_new_cc_IBlockInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBlockInfo *result; + result = (cc::IBlockInfo *)new cc::IBlockInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBlockInfo, __jsb_cc_IBlockInfo_class, js_delete_cc_IBlockInfo) + +static bool js_delete_cc_IBlockInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBlockInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBlockInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("members", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->members), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBlockInfo(se::Object* obj) { + auto* cls = se::Class::create("IBlockInfo", obj, nullptr, _SE(js_new_cc_IBlockInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_IBlockInfo_binding_get), _SE(js_cc_IBlockInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IBlockInfo_name_get), _SE(js_cc_IBlockInfo_name_set)); + cls->defineProperty("members", _SE(js_cc_IBlockInfo_members_get), _SE(js_cc_IBlockInfo_members_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IBlockInfo_stageFlags_get), _SE(js_cc_IBlockInfo_stageFlags_set)); + cls->defineProperty("defines", _SE(js_cc_IBlockInfo_defines_get), _SE(js_cc_IBlockInfo_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBlockInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBlockInfo_proto = cls->getProto(); + __jsb_cc_IBlockInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISamplerTextureInfo_class = nullptr; +se::Object* __jsb_cc_ISamplerTextureInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISamplerTextureInfo) + +static bool js_cc_ISamplerTextureInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_binding_set) + +static bool js_cc_ISamplerTextureInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_binding_get) + +static bool js_cc_ISamplerTextureInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_name_set) + +static bool js_cc_ISamplerTextureInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_name_get) + +static bool js_cc_ISamplerTextureInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_type_set) + +static bool js_cc_ISamplerTextureInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_type_get) + +static bool js_cc_ISamplerTextureInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_count_set) + +static bool js_cc_ISamplerTextureInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_count_get) + +static bool js_cc_ISamplerTextureInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_stageFlags_set) + +static bool js_cc_ISamplerTextureInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_stageFlags_get) + +static bool js_cc_ISamplerTextureInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_defines_set) + +static bool js_cc_ISamplerTextureInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_defines_get) + +static bool js_new_cc_ISamplerTextureInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ISamplerTextureInfo *result; + result = (cc::ISamplerTextureInfo *)new cc::ISamplerTextureInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ISamplerTextureInfo, __jsb_cc_ISamplerTextureInfo_class, js_delete_cc_ISamplerTextureInfo) + +static bool js_delete_cc_ISamplerTextureInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISamplerTextureInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerTextureInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_ISamplerTextureInfo(se::Object* obj) { + auto* cls = se::Class::create("ISamplerTextureInfo", obj, nullptr, _SE(js_new_cc_ISamplerTextureInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_ISamplerTextureInfo_binding_get), _SE(js_cc_ISamplerTextureInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_ISamplerTextureInfo_name_get), _SE(js_cc_ISamplerTextureInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_ISamplerTextureInfo_type_get), _SE(js_cc_ISamplerTextureInfo_type_set)); + cls->defineProperty("count", _SE(js_cc_ISamplerTextureInfo_count_get), _SE(js_cc_ISamplerTextureInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_ISamplerTextureInfo_stageFlags_get), _SE(js_cc_ISamplerTextureInfo_stageFlags_set)); + cls->defineProperty("defines", _SE(js_cc_ISamplerTextureInfo_defines_get), _SE(js_cc_ISamplerTextureInfo_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISamplerTextureInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISamplerTextureInfo_proto = cls->getProto(); + __jsb_cc_ISamplerTextureInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITextureInfo_class = nullptr; +se::Object* __jsb_cc_ITextureInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITextureInfo) + +static bool js_cc_ITextureInfo_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_set_set) + +static bool js_cc_ITextureInfo_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_set_get) + +static bool js_cc_ITextureInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_binding_set) + +static bool js_cc_ITextureInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_binding_get) + +static bool js_cc_ITextureInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_name_set) + +static bool js_cc_ITextureInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_name_get) + +static bool js_cc_ITextureInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_type_set) + +static bool js_cc_ITextureInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_type_get) + +static bool js_cc_ITextureInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_count_set) + +static bool js_cc_ITextureInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_count_get) + +static bool js_cc_ITextureInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_stageFlags_set) + +static bool js_cc_ITextureInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_stageFlags_get) + +static bool js_new_cc_ITextureInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITextureInfo *result; + result = (cc::ITextureInfo *)new cc::ITextureInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITextureInfo, __jsb_cc_ITextureInfo_class, js_delete_cc_ITextureInfo) + +static bool js_delete_cc_ITextureInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITextureInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITextureInfo(se::Object* obj) { + auto* cls = se::Class::create("ITextureInfo", obj, nullptr, _SE(js_new_cc_ITextureInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_ITextureInfo_set_get), _SE(js_cc_ITextureInfo_set_set)); + cls->defineProperty("binding", _SE(js_cc_ITextureInfo_binding_get), _SE(js_cc_ITextureInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_ITextureInfo_name_get), _SE(js_cc_ITextureInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_ITextureInfo_type_get), _SE(js_cc_ITextureInfo_type_set)); + cls->defineProperty("count", _SE(js_cc_ITextureInfo_count_get), _SE(js_cc_ITextureInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_ITextureInfo_stageFlags_get), _SE(js_cc_ITextureInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITextureInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITextureInfo_proto = cls->getProto(); + __jsb_cc_ITextureInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISamplerInfo_class = nullptr; +se::Object* __jsb_cc_ISamplerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISamplerInfo) + +static bool js_cc_ISamplerInfo_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_set_set) + +static bool js_cc_ISamplerInfo_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_set_get) + +static bool js_cc_ISamplerInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_binding_set) + +static bool js_cc_ISamplerInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_binding_get) + +static bool js_cc_ISamplerInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_name_set) + +static bool js_cc_ISamplerInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_name_get) + +static bool js_cc_ISamplerInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_count_set) + +static bool js_cc_ISamplerInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_count_get) + +static bool js_cc_ISamplerInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_stageFlags_set) + +static bool js_cc_ISamplerInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_stageFlags_get) + +static bool js_new_cc_ISamplerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ISamplerInfo *result; + result = (cc::ISamplerInfo *)new cc::ISamplerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ISamplerInfo, __jsb_cc_ISamplerInfo_class, js_delete_cc_ISamplerInfo) + +static bool js_delete_cc_ISamplerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISamplerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_ISamplerInfo(se::Object* obj) { + auto* cls = se::Class::create("ISamplerInfo", obj, nullptr, _SE(js_new_cc_ISamplerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_ISamplerInfo_set_get), _SE(js_cc_ISamplerInfo_set_set)); + cls->defineProperty("binding", _SE(js_cc_ISamplerInfo_binding_get), _SE(js_cc_ISamplerInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_ISamplerInfo_name_get), _SE(js_cc_ISamplerInfo_name_set)); + cls->defineProperty("count", _SE(js_cc_ISamplerInfo_count_get), _SE(js_cc_ISamplerInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_ISamplerInfo_stageFlags_get), _SE(js_cc_ISamplerInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISamplerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISamplerInfo_proto = cls->getProto(); + __jsb_cc_ISamplerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBufferInfo_class = nullptr; +se::Object* __jsb_cc_IBufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBufferInfo) + +static bool js_cc_IBufferInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_binding_set) + +static bool js_cc_IBufferInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_binding_get) + +static bool js_cc_IBufferInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_name_set) + +static bool js_cc_IBufferInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_name_get) + +static bool js_cc_IBufferInfo_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_memoryAccess_set) + +static bool js_cc_IBufferInfo_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_memoryAccess_get) + +static bool js_cc_IBufferInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_stageFlags_set) + +static bool js_cc_IBufferInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_stageFlags_get) + +static bool js_new_cc_IBufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBufferInfo *result; + result = (cc::IBufferInfo *)new cc::IBufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBufferInfo, __jsb_cc_IBufferInfo_class, js_delete_cc_IBufferInfo) + +static bool js_delete_cc_IBufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBufferInfo(se::Object* obj) { + auto* cls = se::Class::create("IBufferInfo", obj, nullptr, _SE(js_new_cc_IBufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_IBufferInfo_binding_get), _SE(js_cc_IBufferInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IBufferInfo_name_get), _SE(js_cc_IBufferInfo_name_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_IBufferInfo_memoryAccess_get), _SE(js_cc_IBufferInfo_memoryAccess_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IBufferInfo_stageFlags_get), _SE(js_cc_IBufferInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBufferInfo_proto = cls->getProto(); + __jsb_cc_IBufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IImageInfo_class = nullptr; +se::Object* __jsb_cc_IImageInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IImageInfo) + +static bool js_cc_IImageInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_binding_set) + +static bool js_cc_IImageInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_binding_get) + +static bool js_cc_IImageInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_name_set) + +static bool js_cc_IImageInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_name_get) + +static bool js_cc_IImageInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_type_set) + +static bool js_cc_IImageInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_type_get) + +static bool js_cc_IImageInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_count_set) + +static bool js_cc_IImageInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_count_get) + +static bool js_cc_IImageInfo_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_memoryAccess_set) + +static bool js_cc_IImageInfo_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_memoryAccess_get) + +static bool js_cc_IImageInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_stageFlags_set) + +static bool js_cc_IImageInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_stageFlags_get) + +static bool js_new_cc_IImageInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IImageInfo *result; + result = (cc::IImageInfo *)new cc::IImageInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IImageInfo, __jsb_cc_IImageInfo_class, js_delete_cc_IImageInfo) + +static bool js_delete_cc_IImageInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IImageInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IImageInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_IImageInfo(se::Object* obj) { + auto* cls = se::Class::create("IImageInfo", obj, nullptr, _SE(js_new_cc_IImageInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_IImageInfo_binding_get), _SE(js_cc_IImageInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IImageInfo_name_get), _SE(js_cc_IImageInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_IImageInfo_type_get), _SE(js_cc_IImageInfo_type_set)); + cls->defineProperty("count", _SE(js_cc_IImageInfo_count_get), _SE(js_cc_IImageInfo_count_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_IImageInfo_memoryAccess_get), _SE(js_cc_IImageInfo_memoryAccess_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IImageInfo_stageFlags_get), _SE(js_cc_IImageInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IImageInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IImageInfo_proto = cls->getProto(); + __jsb_cc_IImageInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IInputAttachmentInfo_class = nullptr; +se::Object* __jsb_cc_IInputAttachmentInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IInputAttachmentInfo) + +static bool js_cc_IInputAttachmentInfo_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_set_set) + +static bool js_cc_IInputAttachmentInfo_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_set_get) + +static bool js_cc_IInputAttachmentInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_binding_set) + +static bool js_cc_IInputAttachmentInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_binding_get) + +static bool js_cc_IInputAttachmentInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_name_set) + +static bool js_cc_IInputAttachmentInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_name_get) + +static bool js_cc_IInputAttachmentInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_count_set) + +static bool js_cc_IInputAttachmentInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_count_get) + +static bool js_cc_IInputAttachmentInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_stageFlags_set) + +static bool js_cc_IInputAttachmentInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_stageFlags_get) + +static bool js_new_cc_IInputAttachmentInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IInputAttachmentInfo *result; + result = (cc::IInputAttachmentInfo *)new cc::IInputAttachmentInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IInputAttachmentInfo, __jsb_cc_IInputAttachmentInfo_class, js_delete_cc_IInputAttachmentInfo) + +static bool js_delete_cc_IInputAttachmentInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IInputAttachmentInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IInputAttachmentInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_IInputAttachmentInfo(se::Object* obj) { + auto* cls = se::Class::create("IInputAttachmentInfo", obj, nullptr, _SE(js_new_cc_IInputAttachmentInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_IInputAttachmentInfo_set_get), _SE(js_cc_IInputAttachmentInfo_set_set)); + cls->defineProperty("binding", _SE(js_cc_IInputAttachmentInfo_binding_get), _SE(js_cc_IInputAttachmentInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IInputAttachmentInfo_name_get), _SE(js_cc_IInputAttachmentInfo_name_set)); + cls->defineProperty("count", _SE(js_cc_IInputAttachmentInfo_count_get), _SE(js_cc_IInputAttachmentInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IInputAttachmentInfo_stageFlags_get), _SE(js_cc_IInputAttachmentInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IInputAttachmentInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IInputAttachmentInfo_proto = cls->getProto(); + __jsb_cc_IInputAttachmentInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IAttributeInfo_class = nullptr; +se::Object* __jsb_cc_IAttributeInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IAttributeInfo) + +static bool js_cc_IAttributeInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_name_set) + +static bool js_cc_IAttributeInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_name_get) + +static bool js_cc_IAttributeInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_format_set) + +static bool js_cc_IAttributeInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_format_get) + +static bool js_cc_IAttributeInfo_isNormalized_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isNormalized); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_isNormalized_set) + +static bool js_cc_IAttributeInfo_isNormalized_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isNormalized, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_isNormalized_get) + +static bool js_cc_IAttributeInfo_stream_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stream, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_stream_set) + +static bool js_cc_IAttributeInfo_stream_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stream, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_stream_get) + +static bool js_cc_IAttributeInfo_isInstanced_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isInstanced); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_isInstanced_set) + +static bool js_cc_IAttributeInfo_isInstanced_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isInstanced, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_isInstanced_get) + +static bool js_cc_IAttributeInfo_location_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->location, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_location_set) + +static bool js_cc_IAttributeInfo_location_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->location, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_location_get) + +static bool js_cc_IAttributeInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_defines_set) + +static bool js_cc_IAttributeInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_defines_get) + +static bool js_new_cc_IAttributeInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IAttributeInfo *result; + result = (cc::IAttributeInfo *)new cc::IAttributeInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IAttributeInfo, __jsb_cc_IAttributeInfo_class, js_delete_cc_IAttributeInfo) + +static bool js_delete_cc_IAttributeInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IAttributeInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IAttributeInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("isNormalized", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isNormalized), ctx); + } + + + json->getProperty("stream", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stream), ctx); + } + + + json->getProperty("isInstanced", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isInstanced), ctx); + } + + + json->getProperty("location", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->location), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_IAttributeInfo(se::Object* obj) { + auto* cls = se::Class::create("IAttributeInfo", obj, nullptr, _SE(js_new_cc_IAttributeInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IAttributeInfo_name_get), _SE(js_cc_IAttributeInfo_name_set)); + cls->defineProperty("format", _SE(js_cc_IAttributeInfo_format_get), _SE(js_cc_IAttributeInfo_format_set)); + cls->defineProperty("isNormalized", _SE(js_cc_IAttributeInfo_isNormalized_get), _SE(js_cc_IAttributeInfo_isNormalized_set)); + cls->defineProperty("stream", _SE(js_cc_IAttributeInfo_stream_get), _SE(js_cc_IAttributeInfo_stream_set)); + cls->defineProperty("isInstanced", _SE(js_cc_IAttributeInfo_isInstanced_get), _SE(js_cc_IAttributeInfo_isInstanced_set)); + cls->defineProperty("location", _SE(js_cc_IAttributeInfo_location_get), _SE(js_cc_IAttributeInfo_location_set)); + cls->defineProperty("defines", _SE(js_cc_IAttributeInfo_defines_get), _SE(js_cc_IAttributeInfo_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IAttributeInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IAttributeInfo_proto = cls->getProto(); + __jsb_cc_IAttributeInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDefineInfo_class = nullptr; +se::Object* __jsb_cc_IDefineInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDefineInfo) + +static bool js_cc_IDefineInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_name_set) + +static bool js_cc_IDefineInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_name_get) + +static bool js_cc_IDefineInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_type_set) + +static bool js_cc_IDefineInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_type_get) + +static bool js_cc_IDefineInfo_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->range, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_range_set) + +static bool js_cc_IDefineInfo_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->range, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->range, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_range_get) + +static bool js_cc_IDefineInfo_options_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->options, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_options_set) + +static bool js_cc_IDefineInfo_options_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->options, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->options, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_options_get) + +static bool js_cc_IDefineInfo_defaultVal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defaultVal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_defaultVal_set) + +static bool js_cc_IDefineInfo_defaultVal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defaultVal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defaultVal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_defaultVal_get) + +static bool js_cc_IDefineInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_defines_set) + +static bool js_cc_IDefineInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_defines_get) + +static bool js_cc_IDefineInfo_editor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->editor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_editor_set) + +static bool js_cc_IDefineInfo_editor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->editor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->editor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_editor_get) + +static bool js_new_cc_IDefineInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDefineInfo *result; + result = (cc::IDefineInfo *)new cc::IDefineInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDefineInfo, __jsb_cc_IDefineInfo_class, js_delete_cc_IDefineInfo) + +static bool js_delete_cc_IDefineInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDefineInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("range", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->range), ctx); + } + + + json->getProperty("options", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->options), ctx); + } + + + json->getProperty("defaultVal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defaultVal), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("editor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->editor), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDefineInfo(se::Object* obj) { + auto* cls = se::Class::create("IDefineInfo", obj, nullptr, _SE(js_new_cc_IDefineInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IDefineInfo_name_get), _SE(js_cc_IDefineInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_IDefineInfo_type_get), _SE(js_cc_IDefineInfo_type_set)); + cls->defineProperty("range", _SE(js_cc_IDefineInfo_range_get), _SE(js_cc_IDefineInfo_range_set)); + cls->defineProperty("options", _SE(js_cc_IDefineInfo_options_get), _SE(js_cc_IDefineInfo_options_set)); + cls->defineProperty("defaultVal", _SE(js_cc_IDefineInfo_defaultVal_get), _SE(js_cc_IDefineInfo_defaultVal_set)); + cls->defineProperty("defines", _SE(js_cc_IDefineInfo_defines_get), _SE(js_cc_IDefineInfo_defines_set)); + cls->defineProperty("editor", _SE(js_cc_IDefineInfo_editor_get), _SE(js_cc_IDefineInfo_editor_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDefineInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDefineInfo_proto = cls->getProto(); + __jsb_cc_IDefineInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBuiltin_class = nullptr; +se::Object* __jsb_cc_IBuiltin_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBuiltin) + +static bool js_cc_IBuiltin_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltin_name_set) + +static bool js_cc_IBuiltin_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltin_name_get) + +static bool js_cc_IBuiltin_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltin_defines_set) + +static bool js_cc_IBuiltin_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltin_defines_get) + +static bool js_new_cc_IBuiltin(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBuiltin *result; + result = (cc::IBuiltin *)new cc::IBuiltin(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBuiltin, __jsb_cc_IBuiltin_class, js_delete_cc_IBuiltin) + +static bool js_delete_cc_IBuiltin(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBuiltin) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltin * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBuiltin(se::Object* obj) { + auto* cls = se::Class::create("IBuiltin", obj, nullptr, _SE(js_new_cc_IBuiltin)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IBuiltin_name_get), _SE(js_cc_IBuiltin_name_set)); + cls->defineProperty("defines", _SE(js_cc_IBuiltin_defines_get), _SE(js_cc_IBuiltin_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBuiltin)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBuiltin_proto = cls->getProto(); + __jsb_cc_IBuiltin_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBuiltinInfo_class = nullptr; +se::Object* __jsb_cc_IBuiltinInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBuiltinInfo) + +static bool js_cc_IBuiltinInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_buffers_set) + +static bool js_cc_IBuiltinInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_buffers_get) + +static bool js_cc_IBuiltinInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_blocks_set) + +static bool js_cc_IBuiltinInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_blocks_get) + +static bool js_cc_IBuiltinInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_samplerTextures_set) + +static bool js_cc_IBuiltinInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_samplerTextures_get) + +static bool js_cc_IBuiltinInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_images_set) + +static bool js_cc_IBuiltinInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_images_get) + +static bool js_new_cc_IBuiltinInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBuiltinInfo *result; + result = (cc::IBuiltinInfo *)new cc::IBuiltinInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBuiltinInfo, __jsb_cc_IBuiltinInfo_class, js_delete_cc_IBuiltinInfo) + +static bool js_delete_cc_IBuiltinInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBuiltinInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltinInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBuiltinInfo(se::Object* obj) { + auto* cls = se::Class::create("IBuiltinInfo", obj, nullptr, _SE(js_new_cc_IBuiltinInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffers", _SE(js_cc_IBuiltinInfo_buffers_get), _SE(js_cc_IBuiltinInfo_buffers_set)); + cls->defineProperty("blocks", _SE(js_cc_IBuiltinInfo_blocks_get), _SE(js_cc_IBuiltinInfo_blocks_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_IBuiltinInfo_samplerTextures_get), _SE(js_cc_IBuiltinInfo_samplerTextures_set)); + cls->defineProperty("images", _SE(js_cc_IBuiltinInfo_images_get), _SE(js_cc_IBuiltinInfo_images_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBuiltinInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBuiltinInfo_proto = cls->getProto(); + __jsb_cc_IBuiltinInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBuiltins_class = nullptr; +se::Object* __jsb_cc_IBuiltins_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBuiltins) + +static bool js_cc_IBuiltins_globals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->globals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltins_globals_set) + +static bool js_cc_IBuiltins_globals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->globals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->globals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltins_globals_get) + +static bool js_cc_IBuiltins_locals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->locals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltins_locals_set) + +static bool js_cc_IBuiltins_locals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->locals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->locals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltins_locals_get) + +static bool js_cc_IBuiltins_statistics_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->statistics, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltins_statistics_set) + +static bool js_cc_IBuiltins_statistics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->statistics, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->statistics, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltins_statistics_get) + +static bool js_new_cc_IBuiltins(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBuiltins *result; + result = (cc::IBuiltins *)new cc::IBuiltins(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBuiltins, __jsb_cc_IBuiltins_class, js_delete_cc_IBuiltins) + +static bool js_delete_cc_IBuiltins(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBuiltins) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltins * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("globals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->globals), ctx); + } + + + json->getProperty("locals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->locals), ctx); + } + + + json->getProperty("statistics", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->statistics), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBuiltins(se::Object* obj) { + auto* cls = se::Class::create("IBuiltins", obj, nullptr, _SE(js_new_cc_IBuiltins)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("globals", _SE(js_cc_IBuiltins_globals_get), _SE(js_cc_IBuiltins_globals_set)); + cls->defineProperty("locals", _SE(js_cc_IBuiltins_locals_get), _SE(js_cc_IBuiltins_locals_set)); + cls->defineProperty("statistics", _SE(js_cc_IBuiltins_statistics_get), _SE(js_cc_IBuiltins_statistics_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBuiltins)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBuiltins_proto = cls->getProto(); + __jsb_cc_IBuiltins_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDescriptorInfo_class = nullptr; +se::Object* __jsb_cc_IDescriptorInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDescriptorInfo) + +static bool js_cc_IDescriptorInfo_rate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rate, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_rate_set) + +static bool js_cc_IDescriptorInfo_rate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_rate_get) + +static bool js_cc_IDescriptorInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_blocks_set) + +static bool js_cc_IDescriptorInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_blocks_get) + +static bool js_cc_IDescriptorInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_samplerTextures_set) + +static bool js_cc_IDescriptorInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_samplerTextures_get) + +static bool js_cc_IDescriptorInfo_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_samplers_set) + +static bool js_cc_IDescriptorInfo_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_samplers_get) + +static bool js_cc_IDescriptorInfo_textures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_textures_set) + +static bool js_cc_IDescriptorInfo_textures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_textures_get) + +static bool js_cc_IDescriptorInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_buffers_set) + +static bool js_cc_IDescriptorInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_buffers_get) + +static bool js_cc_IDescriptorInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_images_set) + +static bool js_cc_IDescriptorInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_images_get) + +static bool js_cc_IDescriptorInfo_subpassInputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassInputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_subpassInputs_set) + +static bool js_cc_IDescriptorInfo_subpassInputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassInputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpassInputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_subpassInputs_get) + +static bool js_new_cc_IDescriptorInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDescriptorInfo *result; + result = (cc::IDescriptorInfo *)new cc::IDescriptorInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDescriptorInfo, __jsb_cc_IDescriptorInfo_class, js_delete_cc_IDescriptorInfo) + +static bool js_delete_cc_IDescriptorInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDescriptorInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDescriptorInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("rate", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rate), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("textures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textures), ctx); + } + + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + json->getProperty("subpassInputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassInputs), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDescriptorInfo(se::Object* obj) { + auto* cls = se::Class::create("IDescriptorInfo", obj, nullptr, _SE(js_new_cc_IDescriptorInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("rate", _SE(js_cc_IDescriptorInfo_rate_get), _SE(js_cc_IDescriptorInfo_rate_set)); + cls->defineProperty("blocks", _SE(js_cc_IDescriptorInfo_blocks_get), _SE(js_cc_IDescriptorInfo_blocks_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_IDescriptorInfo_samplerTextures_get), _SE(js_cc_IDescriptorInfo_samplerTextures_set)); + cls->defineProperty("samplers", _SE(js_cc_IDescriptorInfo_samplers_get), _SE(js_cc_IDescriptorInfo_samplers_set)); + cls->defineProperty("textures", _SE(js_cc_IDescriptorInfo_textures_get), _SE(js_cc_IDescriptorInfo_textures_set)); + cls->defineProperty("buffers", _SE(js_cc_IDescriptorInfo_buffers_get), _SE(js_cc_IDescriptorInfo_buffers_set)); + cls->defineProperty("images", _SE(js_cc_IDescriptorInfo_images_get), _SE(js_cc_IDescriptorInfo_images_set)); + cls->defineProperty("subpassInputs", _SE(js_cc_IDescriptorInfo_subpassInputs_get), _SE(js_cc_IDescriptorInfo_subpassInputs_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDescriptorInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDescriptorInfo_proto = cls->getProto(); + __jsb_cc_IDescriptorInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IShaderSource_class = nullptr; +se::Object* __jsb_cc_IShaderSource_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IShaderSource) + +static bool js_cc_IShaderSource_vert_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vert, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderSource_vert_set) + +static bool js_cc_IShaderSource_vert_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vert, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vert, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderSource_vert_get) + +static bool js_cc_IShaderSource_frag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderSource_frag_set) + +static bool js_cc_IShaderSource_frag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frag, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->frag, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderSource_frag_get) + +static bool js_cc_IShaderSource_compute_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compute, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderSource_compute_set) + +static bool js_cc_IShaderSource_compute_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compute, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->compute, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderSource_compute_get) + +static bool js_new_cc_IShaderSource(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IShaderSource *result; + result = (cc::IShaderSource *)new cc::IShaderSource(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IShaderSource, __jsb_cc_IShaderSource_class, js_delete_cc_IShaderSource) + +static bool js_delete_cc_IShaderSource(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IShaderSource) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderSource * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vert", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vert), ctx); + } + + + json->getProperty("frag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frag), ctx); + } + + + json->getProperty("compute", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compute), ctx); + } + + + return ok; +} + + +bool js_register_cc_IShaderSource(se::Object* obj) { + auto* cls = se::Class::create("IShaderSource", obj, nullptr, _SE(js_new_cc_IShaderSource)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vert", _SE(js_cc_IShaderSource_vert_get), _SE(js_cc_IShaderSource_vert_set)); + cls->defineProperty("frag", _SE(js_cc_IShaderSource_frag_get), _SE(js_cc_IShaderSource_frag_set)); + cls->defineProperty("compute", _SE(js_cc_IShaderSource_compute_get), _SE(js_cc_IShaderSource_compute_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IShaderSource)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IShaderSource_proto = cls->getProto(); + __jsb_cc_IShaderSource_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IShaderInfo_class = nullptr; +se::Object* __jsb_cc_IShaderInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IShaderInfo) + +static bool js_cc_IShaderInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_name_set) + +static bool js_cc_IShaderInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_name_get) + +static bool js_cc_IShaderInfo_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_hash_set) + +static bool js_cc_IShaderInfo_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hash, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->hash, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_hash_get) + +static bool js_cc_IShaderInfo_glsl4_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->glsl4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_glsl4_set) + +static bool js_cc_IShaderInfo_glsl4_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->glsl4, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->glsl4, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_glsl4_get) + +static bool js_cc_IShaderInfo_glsl3_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->glsl3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_glsl3_set) + +static bool js_cc_IShaderInfo_glsl3_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->glsl3, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->glsl3, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_glsl3_get) + +static bool js_cc_IShaderInfo_glsl1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->glsl1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_glsl1_set) + +static bool js_cc_IShaderInfo_glsl1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->glsl1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->glsl1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_glsl1_get) + +static bool js_cc_IShaderInfo_builtins_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->builtins, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_builtins_set) + +static bool js_cc_IShaderInfo_builtins_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->builtins, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->builtins, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_builtins_get) + +static bool js_cc_IShaderInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_defines_set) + +static bool js_cc_IShaderInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_defines_get) + +static bool js_cc_IShaderInfo_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_attributes_set) + +static bool js_cc_IShaderInfo_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_attributes_get) + +static bool js_cc_IShaderInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_blocks_set) + +static bool js_cc_IShaderInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_blocks_get) + +static bool js_cc_IShaderInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_samplerTextures_set) + +static bool js_cc_IShaderInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_samplerTextures_get) + +static bool js_cc_IShaderInfo_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_samplers_set) + +static bool js_cc_IShaderInfo_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_samplers_get) + +static bool js_cc_IShaderInfo_textures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_textures_set) + +static bool js_cc_IShaderInfo_textures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_textures_get) + +static bool js_cc_IShaderInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_buffers_set) + +static bool js_cc_IShaderInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_buffers_get) + +static bool js_cc_IShaderInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_images_set) + +static bool js_cc_IShaderInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_images_get) + +static bool js_cc_IShaderInfo_subpassInputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassInputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_subpassInputs_set) + +static bool js_cc_IShaderInfo_subpassInputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassInputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpassInputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_subpassInputs_get) + +static bool js_cc_IShaderInfo_descriptors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->descriptors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_descriptors_set) + +static bool js_cc_IShaderInfo_descriptors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->descriptors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->descriptors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_descriptors_get) + +static bool js_cc_IShaderInfo_getSource__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::IShaderSource *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::IShaderSource *)((cc::IShaderInfo const *)arg1)->getSource((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; +} + +static bool js_cc_IShaderInfo_getSource__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::IShaderSource *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::IShaderSource *)(arg1)->getSource((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; +} + +static bool js_cc_IShaderInfo_getSource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_IShaderInfo_getSource__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_IShaderInfo_getSource__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_IShaderInfo_getSource) + +static bool js_new_cc_IShaderInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IShaderInfo *result; + result = (cc::IShaderInfo *)new cc::IShaderInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IShaderInfo, __jsb_cc_IShaderInfo_class, js_delete_cc_IShaderInfo) + +static bool js_delete_cc_IShaderInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IShaderInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("hash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hash), ctx); + } + + + json->getProperty("glsl4", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->glsl4), ctx); + } + + + json->getProperty("glsl3", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->glsl3), ctx); + } + + + json->getProperty("glsl1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->glsl1), ctx); + } + + + json->getProperty("builtins", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->builtins), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("textures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textures), ctx); + } + + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + json->getProperty("subpassInputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassInputs), ctx); + } + + + json->getProperty("descriptors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->descriptors), ctx); + } + + + return ok; +} + + +bool js_register_cc_IShaderInfo(se::Object* obj) { + auto* cls = se::Class::create("IShaderInfo", obj, nullptr, _SE(js_new_cc_IShaderInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IShaderInfo_name_get), _SE(js_cc_IShaderInfo_name_set)); + cls->defineProperty("hash", _SE(js_cc_IShaderInfo_hash_get), _SE(js_cc_IShaderInfo_hash_set)); + cls->defineProperty("glsl4", _SE(js_cc_IShaderInfo_glsl4_get), _SE(js_cc_IShaderInfo_glsl4_set)); + cls->defineProperty("glsl3", _SE(js_cc_IShaderInfo_glsl3_get), _SE(js_cc_IShaderInfo_glsl3_set)); + cls->defineProperty("glsl1", _SE(js_cc_IShaderInfo_glsl1_get), _SE(js_cc_IShaderInfo_glsl1_set)); + cls->defineProperty("builtins", _SE(js_cc_IShaderInfo_builtins_get), _SE(js_cc_IShaderInfo_builtins_set)); + cls->defineProperty("defines", _SE(js_cc_IShaderInfo_defines_get), _SE(js_cc_IShaderInfo_defines_set)); + cls->defineProperty("attributes", _SE(js_cc_IShaderInfo_attributes_get), _SE(js_cc_IShaderInfo_attributes_set)); + cls->defineProperty("blocks", _SE(js_cc_IShaderInfo_blocks_get), _SE(js_cc_IShaderInfo_blocks_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_IShaderInfo_samplerTextures_get), _SE(js_cc_IShaderInfo_samplerTextures_set)); + cls->defineProperty("samplers", _SE(js_cc_IShaderInfo_samplers_get), _SE(js_cc_IShaderInfo_samplers_set)); + cls->defineProperty("textures", _SE(js_cc_IShaderInfo_textures_get), _SE(js_cc_IShaderInfo_textures_set)); + cls->defineProperty("buffers", _SE(js_cc_IShaderInfo_buffers_get), _SE(js_cc_IShaderInfo_buffers_set)); + cls->defineProperty("images", _SE(js_cc_IShaderInfo_images_get), _SE(js_cc_IShaderInfo_images_set)); + cls->defineProperty("subpassInputs", _SE(js_cc_IShaderInfo_subpassInputs_get), _SE(js_cc_IShaderInfo_subpassInputs_set)); + cls->defineProperty("descriptors", _SE(js_cc_IShaderInfo_descriptors_get), _SE(js_cc_IShaderInfo_descriptors_set)); + + cls->defineFunction("getSource", _SE(js_cc_IShaderInfo_getSource)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IShaderInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IShaderInfo_proto = cls->getProto(); + __jsb_cc_IShaderInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_EffectAsset_class = nullptr; +se::Object* __jsb_cc_EffectAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_EffectAsset) + +static bool js_new_cc_EffectAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::EffectAsset *result; + result = (cc::EffectAsset *)new cc::EffectAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_EffectAsset, __jsb_cc_EffectAsset_class, js_delete_cc_EffectAsset) + +static bool js_delete_cc_EffectAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_EffectAsset) + +static bool js_cc_EffectAsset_cpp_keyword_register_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) 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::EffectAsset::registerAsset(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_EffectAsset_cpp_keyword_register_static) + +static bool js_cc_EffectAsset_remove_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + cc::EffectAsset::remove((ccstd::string const &)*arg1); + + + return true; +} + +static bool js_cc_EffectAsset_remove_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::EffectAsset::remove(arg1); + + + return true; +} + +static bool js_cc_EffectAsset_remove_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_EffectAsset_remove_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_EffectAsset_remove_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_EffectAsset_remove_static) + +static bool js_cc_EffectAsset_get_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::EffectAsset *result = 0 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::EffectAsset *)cc::EffectAsset::get((ccstd::string const &)*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_FUNC(js_cc_EffectAsset_get_static) + +static bool js_cc_EffectAsset_getAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset::RegisteredEffectAssetMap *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::EffectAsset::RegisteredEffectAssetMap *) &cc::EffectAsset::getAll(); + + 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_EffectAsset_getAll_static) + +static bool js_cc_EffectAsset_isLayoutValid_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)cc::EffectAsset::isLayoutValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_EffectAsset_isLayoutValid_static) + +static bool js_cc_EffectAsset_setLayoutValid_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::EffectAsset::setLayoutValid(); + + + return true; +} +SE_BIND_FUNC(js_cc_EffectAsset_setLayoutValid_static) + +static bool js_cc_EffectAsset_hideInEditor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hideInEditor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_hideInEditor_set) + +static bool js_cc_EffectAsset_hideInEditor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hideInEditor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_EffectAsset_hideInEditor_get) + +static bool js_cc_EffectAsset_techniques_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::ITechniqueInfo > *arg2 = 0 ; + ccstd::vector< cc::ITechniqueInfo > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_EffectAsset_techniques_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_techniques_set) + +static bool js_cc_EffectAsset_techniques_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::ITechniqueInfo > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::ITechniqueInfo > *) &cc_EffectAsset_techniques_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_EffectAsset_techniques_get) + +static bool js_cc_EffectAsset_shaders_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IShaderInfo > *arg2 = 0 ; + ccstd::vector< cc::IShaderInfo > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_EffectAsset_shaders_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_shaders_set) + +static bool js_cc_EffectAsset_shaders_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IShaderInfo > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IShaderInfo > *) &cc_EffectAsset_shaders_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_EffectAsset_shaders_get) + +static bool js_cc_EffectAsset_combinations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IPreCompileInfo > *arg2 = 0 ; + ccstd::vector< cc::IPreCompileInfo > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_EffectAsset_combinations_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_combinations_set) + +static bool js_cc_EffectAsset_combinations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IPreCompileInfo > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IPreCompileInfo > *) &cc_EffectAsset_combinations_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_EffectAsset_combinations_get) + +bool js_register_cc_EffectAsset(se::Object* obj) { + auto* cls = se::Class::create("EffectAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_EffectAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hideInEditor", _SE(js_cc_EffectAsset_hideInEditor_get), _SE(js_cc_EffectAsset_hideInEditor_set)); + cls->defineProperty("techniques", _SE(js_cc_EffectAsset_techniques_get), _SE(js_cc_EffectAsset_techniques_set)); + cls->defineProperty("shaders", _SE(js_cc_EffectAsset_shaders_get), _SE(js_cc_EffectAsset_shaders_set)); + cls->defineProperty("combinations", _SE(js_cc_EffectAsset_combinations_get), _SE(js_cc_EffectAsset_combinations_set)); + + + + cls->defineStaticFunction("register", _SE(js_cc_EffectAsset_cpp_keyword_register_static)); + cls->defineStaticFunction("remove", _SE(js_cc_EffectAsset_remove_static)); + cls->defineStaticFunction("get", _SE(js_cc_EffectAsset_get_static)); + cls->defineStaticFunction("getAll", _SE(js_cc_EffectAsset_getAll_static)); + cls->defineStaticFunction("isLayoutValid", _SE(js_cc_EffectAsset_isLayoutValid_static)); + cls->defineStaticFunction("setLayoutValid", _SE(js_cc_EffectAsset_setLayoutValid_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_EffectAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_EffectAsset_proto = cls->getProto(); + __jsb_cc_EffectAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMemoryImageSource_class = nullptr; +se::Object* __jsb_cc_IMemoryImageSource_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMemoryImageSource) + +static bool js_cc_IMemoryImageSource_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_width_set) + +static bool js_cc_IMemoryImageSource_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_width_get) + +static bool js_cc_IMemoryImageSource_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_height_set) + +static bool js_cc_IMemoryImageSource_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_height_get) + +static bool js_cc_IMemoryImageSource_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_format_set) + +static bool js_cc_IMemoryImageSource_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_format_get) + +static bool js_cc_IMemoryImageSource_mipmapLevelDataSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapLevelDataSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_mipmapLevelDataSize_set) + +static bool js_cc_IMemoryImageSource_mipmapLevelDataSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapLevelDataSize, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapLevelDataSize, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_mipmapLevelDataSize_get) + +static bool js_new_cc_IMemoryImageSource(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMemoryImageSource *result; + result = (cc::IMemoryImageSource *)new cc::IMemoryImageSource(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMemoryImageSource, __jsb_cc_IMemoryImageSource_class, js_delete_cc_IMemoryImageSource) + +static bool js_delete_cc_IMemoryImageSource(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMemoryImageSource) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMemoryImageSource * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("mipmapLevelDataSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapLevelDataSize), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMemoryImageSource(se::Object* obj) { + auto* cls = se::Class::create("IMemoryImageSource", obj, nullptr, _SE(js_new_cc_IMemoryImageSource)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_IMemoryImageSource_width_get), _SE(js_cc_IMemoryImageSource_width_set)); + cls->defineProperty("height", _SE(js_cc_IMemoryImageSource_height_get), _SE(js_cc_IMemoryImageSource_height_set)); + cls->defineProperty("format", _SE(js_cc_IMemoryImageSource_format_get), _SE(js_cc_IMemoryImageSource_format_set)); + cls->defineProperty("mipmapLevelDataSize", _SE(js_cc_IMemoryImageSource_mipmapLevelDataSize_get), _SE(js_cc_IMemoryImageSource_mipmapLevelDataSize_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMemoryImageSource)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMemoryImageSource_proto = cls->getProto(); + __jsb_cc_IMemoryImageSource_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ImageAsset_class = nullptr; +se::Object* __jsb_cc_ImageAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ImageAsset) + +static bool js_new_cc_ImageAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ImageAsset *result; + result = (cc::ImageAsset *)new cc::ImageAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ImageAsset, __jsb_cc_ImageAsset_class, js_delete_cc_ImageAsset) + +static bool js_delete_cc_ImageAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ImageAsset) + +static bool js_cc_ImageAsset_getData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint8_t *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(s); + if (nullptr == arg1) return true; + result = (uint8_t *)((cc::ImageAsset const *)arg1)->getData(); + + 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_ImageAsset_getData) + +static bool js_cc_ImageAsset_getWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ImageAsset const *)arg1)->getWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_getWidth) + +static bool js_cc_ImageAsset_getHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ImageAsset const *)arg1)->getHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_getHeight) + +static bool js_cc_ImageAsset_getMipmapLevelDataSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::vector< uint32_t > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< uint32_t > *) &((cc::ImageAsset const *)arg1)->getMipmapLevelDataSize(); + + 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_ImageAsset_getMipmapLevelDataSize) + +static bool js_cc_ImageAsset_isCompressed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::ImageAsset const *)arg1)->isCompressed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_isCompressed) + +static bool js_cc_ImageAsset_setWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setWidth) + +static bool js_cc_ImageAsset_setHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setHeight) + +static bool js_cc_ImageAsset_setNeedFreeData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setNeedFreeData(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setNeedFreeData) + +static bool js_cc_ImageAsset_setMipmapLevelDataSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::vector< uint32_t > *arg2 = 0 ; + ccstd::vector< uint32_t > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapLevelDataSize((ccstd::vector< uint32_t > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setMipmapLevelDataSize) + +static bool js_cc_ImageAsset_setFixedFormat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::PixelFormat arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setFixedFormat(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setFixedFormat) + +static bool js_cc_ImageAsset_isFormatFixed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::ImageAsset const *)arg1)->isFormatFixed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_isFormatFixed) + +static bool js_cc_ImageAsset_extractMipmap0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::IntrusivePtr< cc::ImageAsset > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->extractMipmap0(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_extractMipmap0) + +static bool js_cc_ImageAsset_extractMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + std::vector< cc::IntrusivePtr< cc::ImageAsset > > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->extractMipmaps(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_extractMipmaps) + +static bool js_cc_ImageAsset_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::PixelFormat arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_ImageAsset_format_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ImageAsset_format_set) + +static bool js_cc_ImageAsset_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::PixelFormat result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::PixelFormat)cc_ImageAsset_format_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_ImageAsset_format_get) + +static bool js_cc_ImageAsset_url_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ImageAsset_url_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ImageAsset_url_set) + +static bool js_cc_ImageAsset_url_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_ImageAsset_url_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_ImageAsset_url_get) + +bool js_register_cc_ImageAsset(se::Object* obj) { + auto* cls = se::Class::create("ImageAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_ImageAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("format", _SE(js_cc_ImageAsset_format_get), _SE(js_cc_ImageAsset_format_set)); + cls->defineProperty("url", _SE(js_cc_ImageAsset_url_get), _SE(js_cc_ImageAsset_url_set)); + + cls->defineFunction("getData", _SE(js_cc_ImageAsset_getData)); + cls->defineFunction("getWidth", _SE(js_cc_ImageAsset_getWidth)); + cls->defineFunction("getHeight", _SE(js_cc_ImageAsset_getHeight)); + cls->defineFunction("getMipmapLevelDataSize", _SE(js_cc_ImageAsset_getMipmapLevelDataSize)); + cls->defineFunction("isCompressed", _SE(js_cc_ImageAsset_isCompressed)); + cls->defineFunction("setWidth", _SE(js_cc_ImageAsset_setWidth)); + cls->defineFunction("setHeight", _SE(js_cc_ImageAsset_setHeight)); + cls->defineFunction("setNeedFreeData", _SE(js_cc_ImageAsset_setNeedFreeData)); + cls->defineFunction("setMipmapLevelDataSize", _SE(js_cc_ImageAsset_setMipmapLevelDataSize)); + cls->defineFunction("setFixedFormat", _SE(js_cc_ImageAsset_setFixedFormat)); + cls->defineFunction("isFormatFixed", _SE(js_cc_ImageAsset_isFormatFixed)); + cls->defineFunction("extractMipmap0", _SE(js_cc_ImageAsset_extractMipmap0)); + cls->defineFunction("extractMipmaps", _SE(js_cc_ImageAsset_extractMipmaps)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ImageAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ImageAsset_proto = cls->getProto(); + __jsb_cc_ImageAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SceneAsset_class = nullptr; +se::Object* __jsb_cc_SceneAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SceneAsset) + +static bool js_new_cc_SceneAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SceneAsset *result; + result = (cc::SceneAsset *)new cc::SceneAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SceneAsset, __jsb_cc_SceneAsset_class, js_delete_cc_SceneAsset) + +static bool js_delete_cc_SceneAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SceneAsset) + +static bool js_cc_SceneAsset_getScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneAsset *arg1 = (cc::SceneAsset *) NULL ; + cc::Scene *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(s); + if (nullptr == arg1) return true; + result = (cc::Scene *)((cc::SceneAsset const *)arg1)->getScene(); + + 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_SceneAsset_getScene) + +static bool js_cc_SceneAsset_setScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneAsset *arg1 = (cc::SceneAsset *) NULL ; + cc::Scene *arg2 = (cc::Scene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneAsset_setScene) + +bool js_register_cc_SceneAsset(se::Object* obj) { + auto* cls = se::Class::create("SceneAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_SceneAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getScene", _SE(js_cc_SceneAsset_getScene)); + cls->defineFunction("setScene", _SE(js_cc_SceneAsset_setScene)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SceneAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SceneAsset_proto = cls->getProto(); + __jsb_cc_SceneAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextAsset_class = nullptr; +se::Object* __jsb_cc_TextAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextAsset) + +static bool js_new_cc_TextAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextAsset *result; + result = (cc::TextAsset *)new cc::TextAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextAsset, __jsb_cc_TextAsset_class, js_delete_cc_TextAsset) + +static bool js_delete_cc_TextAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextAsset) + +static bool js_cc_TextAsset_text_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextAsset *arg1 = (cc::TextAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->text, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextAsset_text_set) + +static bool js_cc_TextAsset_text_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextAsset *arg1 = (cc::TextAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->text, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->text, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextAsset_text_get) + +bool js_register_cc_TextAsset(se::Object* obj) { + auto* cls = se::Class::create("TextAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_TextAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("text", _SE(js_cc_TextAsset_text_get), _SE(js_cc_TextAsset_text_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextAsset_proto = cls->getProto(); + __jsb_cc_TextAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMaterialInfo_class = nullptr; +se::Object* __jsb_cc_IMaterialInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMaterialInfo) + +static bool js_cc_IMaterialInfo_effectAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->effectAsset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_effectAsset_set) + +static bool js_cc_IMaterialInfo_effectAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->effectAsset, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->effectAsset, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_effectAsset_get) + +static bool js_cc_IMaterialInfo_effectName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->effectName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_effectName_set) + +static bool js_cc_IMaterialInfo_effectName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->effectName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->effectName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_effectName_get) + +static bool js_cc_IMaterialInfo_technique_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->technique, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_technique_set) + +static bool js_cc_IMaterialInfo_technique_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->technique, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->technique, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_technique_get) + +static bool js_cc_IMaterialInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_defines_set) + +static bool js_cc_IMaterialInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_defines_get) + +static bool js_cc_IMaterialInfo_states_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->states, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_states_set) + +static bool js_cc_IMaterialInfo_states_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->states, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->states, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_states_get) + +static bool js_cc_IMaterialInfo_isEmpty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::IMaterialInfo const *)arg1)->isEmpty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_IMaterialInfo_isEmpty) + +static bool js_new_cc_IMaterialInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMaterialInfo *result; + result = (cc::IMaterialInfo *)new cc::IMaterialInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMaterialInfo, __jsb_cc_IMaterialInfo_class, js_delete_cc_IMaterialInfo) + +static bool js_delete_cc_IMaterialInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMaterialInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("effectAsset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->effectAsset), ctx); + } + + + json->getProperty("effectName", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->effectName), ctx); + } + + + json->getProperty("technique", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->technique), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("states", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->states), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMaterialInfo(se::Object* obj) { + auto* cls = se::Class::create("IMaterialInfo", obj, nullptr, _SE(js_new_cc_IMaterialInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("effectAsset", _SE(js_cc_IMaterialInfo_effectAsset_get), _SE(js_cc_IMaterialInfo_effectAsset_set)); + cls->defineProperty("effectName", _SE(js_cc_IMaterialInfo_effectName_get), _SE(js_cc_IMaterialInfo_effectName_set)); + cls->defineProperty("technique", _SE(js_cc_IMaterialInfo_technique_get), _SE(js_cc_IMaterialInfo_technique_set)); + cls->defineProperty("defines", _SE(js_cc_IMaterialInfo_defines_get), _SE(js_cc_IMaterialInfo_defines_set)); + cls->defineProperty("states", _SE(js_cc_IMaterialInfo_states_get), _SE(js_cc_IMaterialInfo_states_set)); + + cls->defineFunction("isEmpty", _SE(js_cc_IMaterialInfo_isEmpty)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMaterialInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMaterialInfo_proto = cls->getProto(); + __jsb_cc_IMaterialInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Material_class = nullptr; +se::Object* __jsb_cc_Material_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Material) + +static bool js_cc_Material_getHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::Material::getHashForMaterial(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_FUNC(js_cc_Material_getHash_static) + +static bool js_new_cc_Material(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Material *result; + result = (cc::Material *)new cc::Material(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Material, __jsb_cc_Material_class, js_delete_cc_Material) + +static bool js_delete_cc_Material(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Material) + +static bool js_cc_Material_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg2 = 0 ; + cc::IMaterialInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::IMaterialInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Material_initialize) + +static bool js_cc_Material_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg2 = 0 ; + cc::IMaterialInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::IMaterialInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Material_reset) + +static bool js_cc_Material_recompileShaders__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::MacroRecord *arg2 = 0 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2); + + + return true; +} + +static bool js_cc_Material_recompileShaders__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::MacroRecord *arg2 = 0 ; + index_t arg3 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_recompileShaders(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Material_recompileShaders__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_recompileShaders__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_recompileShaders) + +static bool js_cc_Material_overridePipelineStates__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::PassOverrides *arg2 = 0 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2); + + + return true; +} + +static bool js_cc_Material_overridePipelineStates__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::PassOverrides *arg2 = 0 ; + index_t arg3 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_overridePipelineStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Material_overridePipelineStates__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_overridePipelineStates__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_overridePipelineStates) + +static bool js_cc_Material_resetUniforms__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resetUniforms(arg2); + + + return true; +} + +static bool js_cc_Material_resetUniforms__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetUniforms(); + + + return true; +} + +static bool js_cc_Material_resetUniforms(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Material_resetUniforms__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Material_resetUniforms__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_resetUniforms) + +static bool js_cc_Material_setPropertyNull__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + index_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyNull((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyNull__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyNull((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_Material_setPropertyNull(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Material_setPropertyNull__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Material_setPropertyNull__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyNull) + +static bool js_cc_Material_setPropertyFloat32__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + float arg3 ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyFloat32((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + float arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyFloat32((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyFloat32__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyFloat32__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyFloat32) + +static bool js_cc_Material_setPropertyInt32__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + int32_t arg3 ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyInt32((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + int32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyInt32((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyInt32__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyInt32__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyInt32) + +static bool js_cc_Material_setPropertyVec2__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec2((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec2((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec2__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec2__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec2) + +static bool js_cc_Material_setPropertyVec3__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec3((ccstd::string const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec3((ccstd::string const &)*arg2,(cc::Vec3 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec3__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec3__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec3) + +static bool js_cc_Material_setPropertyVec4__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec4 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Vec4 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec4((ccstd::string const &)*arg2,(cc::Vec4 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec4 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec4 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec4((ccstd::string const &)*arg2,(cc::Vec4 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec4__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec4__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec4) + +static bool js_cc_Material_setPropertyColor__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Color *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Color temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyColor((ccstd::string const &)*arg2,(cc::Color const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyColor__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Color *arg3 = 0 ; + ccstd::string temp2 ; + cc::Color temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyColor((ccstd::string const &)*arg2,(cc::Color const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyColor__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyColor__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyColor) + +static bool js_cc_Material_setPropertyMat3__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat3 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Mat3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat3((ccstd::string const &)*arg2,(cc::Mat3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat3 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Mat3 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat3((ccstd::string const &)*arg2,(cc::Mat3 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat3__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat3__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat3) + +static bool js_cc_Material_setPropertyMat4__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat4 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Mat4 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat4((ccstd::string const &)*arg2,(cc::Mat4 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat4 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Mat4 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat4((ccstd::string const &)*arg2,(cc::Mat4 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat4__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat4__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat4) + +static bool js_cc_Material_setPropertyQuaternion__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Quaternion *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Quaternion temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyQuaternion((ccstd::string const &)*arg2,(cc::Quaternion const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternion__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Quaternion *arg3 = 0 ; + ccstd::string temp2 ; + cc::Quaternion temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyQuaternion((ccstd::string const &)*arg2,(cc::Quaternion const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyQuaternion__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyQuaternion__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyQuaternion) + +static bool js_cc_Material_setPropertyTextureBase__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TextureBase *arg3 = (cc::TextureBase *) NULL ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyTextureBase((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBase__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TextureBase *arg3 = (cc::TextureBase *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyTextureBase((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBase(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyTextureBase__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyTextureBase__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyTextureBase) + +static bool js_cc_Material_setPropertyGFXTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyGFXTexture((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyGFXTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyGFXTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyGFXTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyGFXTexture) + +static bool js_cc_Material_setPropertyFloat32Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< float > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< float > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyFloat32Array((ccstd::string const &)*arg2,(ccstd::vector< float > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< float > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< float > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyFloat32Array((ccstd::string const &)*arg2,(ccstd::vector< float > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyFloat32Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyFloat32Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyFloat32Array) + +static bool js_cc_Material_setPropertyInt32Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< int32_t > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< int32_t > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyInt32Array((ccstd::string const &)*arg2,(ccstd::vector< int32_t > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< int32_t > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< int32_t > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyInt32Array((ccstd::string const &)*arg2,(ccstd::vector< int32_t > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyInt32Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyInt32Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyInt32Array) + +static bool js_cc_Material_setPropertyVec2Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec2 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec2 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec2Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec2 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec2 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec2 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec2Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec2 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec2Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec2Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec2Array) + +static bool js_cc_Material_setPropertyVec3Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec3Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec3Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec3Array) + +static bool js_cc_Material_setPropertyVec4Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec4 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec4 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec4 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec4 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec4 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec4 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec4Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec4Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec4Array) + +static bool js_cc_Material_setPropertyColorArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Color > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Color > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyColorArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Color > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyColorArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Color > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Color > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyColorArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Color > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyColorArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyColorArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyColorArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyColorArray) + +static bool js_cc_Material_setPropertyMat3Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat3 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat3 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat3 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat3 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat3 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat3Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat3Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat3Array) + +static bool js_cc_Material_setPropertyMat4Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat4 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat4 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat4 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat4 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat4 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat4 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat4Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat4Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat4Array) + +static bool js_cc_Material_setPropertyQuaternionArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Quaternion > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Quaternion > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyQuaternionArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Quaternion > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternionArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Quaternion > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Quaternion > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyQuaternionArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Quaternion > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternionArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyQuaternionArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyQuaternionArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyQuaternionArray) + +static bool js_cc_Material_setPropertyTextureBaseArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::TextureBase * > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::TextureBase * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyTextureBaseArray((ccstd::string const &)*arg2,(ccstd::vector< cc::TextureBase * > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBaseArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::TextureBase * > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::TextureBase * > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyTextureBaseArray((ccstd::string const &)*arg2,(ccstd::vector< cc::TextureBase * > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBaseArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyTextureBaseArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyTextureBaseArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyTextureBaseArray) + +static bool js_cc_Material_setPropertyGFXTextureArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::gfx::Texture * > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::gfx::Texture * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyGFXTextureArray((ccstd::string const &)*arg2,(ccstd::vector< cc::gfx::Texture * > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTextureArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::gfx::Texture * > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::gfx::Texture * > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyGFXTextureArray((ccstd::string const &)*arg2,(ccstd::vector< cc::gfx::Texture * > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTextureArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyGFXTextureArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyGFXTextureArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyGFXTextureArray) + +static bool js_cc_Material__getProperty__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + index_t arg3 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (cc::MaterialPropertyVariant *)((cc::Material const *)arg1)->getProperty((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; +} + +static bool js_cc_Material__getProperty__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::MaterialPropertyVariant *)((cc::Material const *)arg1)->getProperty((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; +} + +static bool js_cc_Material__getProperty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Material__getProperty__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Material__getProperty__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material__getProperty) + +static bool js_cc_Material_copy__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg3 = 0 ; + cc::IMaterialInfo temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->copy((cc::Material const *)arg2,(cc::IMaterialInfo const &)*arg3); + + + return true; +} + +static bool js_cc_Material_copy__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->copy((cc::Material const *)arg2); + + + return true; +} + +static bool js_cc_Material_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Material_copy__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Material_copy__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_copy) + +static bool js_cc_Material_fillInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg2 = 0 ; + cc::IMaterialInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fillInfo((cc::IMaterialInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Material_fillInfo) + +static bool js_cc_Material__effectAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_effectAsset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__effectAsset_set) + +static bool js_cc_Material__effectAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_effectAsset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_effectAsset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__effectAsset_get) + +static bool js_cc_Material__techIdx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_techIdx, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__techIdx_set) + +static bool js_cc_Material__techIdx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_techIdx, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__techIdx_get) + +static bool js_cc_Material__defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__defines_set) + +static bool js_cc_Material__defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__defines_get) + +static bool js_cc_Material__states_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_states, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__states_set) + +static bool js_cc_Material__states_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_states, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_states, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__states_get) + +static bool js_cc_Material__propsInternal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_props, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__propsInternal_set) + +static bool js_cc_Material__propsInternal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_props, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_props, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__propsInternal_get) + +static bool js_cc_Material_getPasses(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + std::shared_ptr< ccstd::vector< cc::IntrusivePtr< cc::scene::Pass > > > *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(s); + if (nullptr == arg1) return true; + result = (std::shared_ptr< ccstd::vector< cc::IntrusivePtr< cc::scene::Pass > > > *) &(arg1)->getPasses(); + + 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_Material_getPasses) + +static bool js_cc_Material_effectAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::EffectAsset *arg2 = (cc::EffectAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Material_effectAsset_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material_effectAsset_set) + +static bool js_cc_Material_effectAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + cc::EffectAsset *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::EffectAsset *)cc_Material_effectAsset_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_Material_effectAsset_get) + +static bool js_cc_Material_effectName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Material_effectName_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_Material_effectName_get) + +static bool js_cc_Material_technique_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Material_technique_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material_technique_get) + +static bool js_cc_Material_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Material_hash_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_Material_hash_get) + +static bool js_cc_Material_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_Material_parent_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_Material_parent_get) + +bool js_register_cc_Material(se::Object* obj) { + auto* cls = se::Class::create("Material", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_Material)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_effectAsset", _SE(js_cc_Material__effectAsset_get), _SE(js_cc_Material__effectAsset_set)); + cls->defineProperty("_techIdx", _SE(js_cc_Material__techIdx_get), _SE(js_cc_Material__techIdx_set)); + cls->defineProperty("_defines", _SE(js_cc_Material__defines_get), _SE(js_cc_Material__defines_set)); + cls->defineProperty("_states", _SE(js_cc_Material__states_get), _SE(js_cc_Material__states_set)); + cls->defineProperty("_propsInternal", _SE(js_cc_Material__propsInternal_get), _SE(js_cc_Material__propsInternal_set)); + cls->defineProperty("effectAsset", _SE(js_cc_Material_effectAsset_get), _SE(js_cc_Material_effectAsset_set)); + cls->defineProperty("effectName", _SE(js_cc_Material_effectName_get), nullptr); + cls->defineProperty("technique", _SE(js_cc_Material_technique_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_Material_hash_get), nullptr); + cls->defineProperty("parent", _SE(js_cc_Material_parent_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_Material_initialize)); + cls->defineFunction("reset", _SE(js_cc_Material_reset)); + cls->defineFunction("recompileShaders", _SE(js_cc_Material_recompileShaders)); + cls->defineFunction("overridePipelineStates", _SE(js_cc_Material_overridePipelineStates)); + cls->defineFunction("resetUniforms", _SE(js_cc_Material_resetUniforms)); + cls->defineFunction("setPropertyNull", _SE(js_cc_Material_setPropertyNull)); + cls->defineFunction("setPropertyFloat32", _SE(js_cc_Material_setPropertyFloat32)); + cls->defineFunction("setPropertyInt32", _SE(js_cc_Material_setPropertyInt32)); + cls->defineFunction("setPropertyVec2", _SE(js_cc_Material_setPropertyVec2)); + cls->defineFunction("setPropertyVec3", _SE(js_cc_Material_setPropertyVec3)); + cls->defineFunction("setPropertyVec4", _SE(js_cc_Material_setPropertyVec4)); + cls->defineFunction("setPropertyColor", _SE(js_cc_Material_setPropertyColor)); + cls->defineFunction("setPropertyMat3", _SE(js_cc_Material_setPropertyMat3)); + cls->defineFunction("setPropertyMat4", _SE(js_cc_Material_setPropertyMat4)); + cls->defineFunction("setPropertyQuaternion", _SE(js_cc_Material_setPropertyQuaternion)); + cls->defineFunction("setPropertyTextureBase", _SE(js_cc_Material_setPropertyTextureBase)); + cls->defineFunction("setPropertyGFXTexture", _SE(js_cc_Material_setPropertyGFXTexture)); + cls->defineFunction("setPropertyFloat32Array", _SE(js_cc_Material_setPropertyFloat32Array)); + cls->defineFunction("setPropertyInt32Array", _SE(js_cc_Material_setPropertyInt32Array)); + cls->defineFunction("setPropertyVec2Array", _SE(js_cc_Material_setPropertyVec2Array)); + cls->defineFunction("setPropertyVec3Array", _SE(js_cc_Material_setPropertyVec3Array)); + cls->defineFunction("setPropertyVec4Array", _SE(js_cc_Material_setPropertyVec4Array)); + cls->defineFunction("setPropertyColorArray", _SE(js_cc_Material_setPropertyColorArray)); + cls->defineFunction("setPropertyMat3Array", _SE(js_cc_Material_setPropertyMat3Array)); + cls->defineFunction("setPropertyMat4Array", _SE(js_cc_Material_setPropertyMat4Array)); + cls->defineFunction("setPropertyQuaternionArray", _SE(js_cc_Material_setPropertyQuaternionArray)); + cls->defineFunction("setPropertyTextureBaseArray", _SE(js_cc_Material_setPropertyTextureBaseArray)); + cls->defineFunction("setPropertyGFXTextureArray", _SE(js_cc_Material_setPropertyGFXTextureArray)); + cls->defineFunction("_getProperty", _SE(js_cc_Material__getProperty)); + cls->defineFunction("copy", _SE(js_cc_Material_copy)); + cls->defineFunction("fillInfo", _SE(js_cc_Material_fillInfo)); + cls->defineFunction("getPasses", _SE(js_cc_Material_getPasses)); + + + cls->defineStaticFunction("getHash", _SE(js_cc_Material_getHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Material)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Material_proto = cls->getProto(); + __jsb_cc_Material_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IGeometricInfo_class = nullptr; +se::Object* __jsb_cc_IGeometricInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IGeometricInfo) + +static bool js_cc_IGeometricInfo_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_positions_set) + +static bool js_cc_IGeometricInfo_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_positions_get) + +static bool js_cc_IGeometricInfo_indices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_indices_set) + +static bool js_cc_IGeometricInfo_indices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_indices_get) + +static bool js_cc_IGeometricInfo_doubleSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->doubleSided, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_doubleSided_set) + +static bool js_cc_IGeometricInfo_doubleSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->doubleSided, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->doubleSided, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_doubleSided_get) + +static bool js_cc_IGeometricInfo_boundingBox_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->boundingBox, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_boundingBox_set) + +static bool js_cc_IGeometricInfo_boundingBox_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->boundingBox, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->boundingBox, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_boundingBox_get) + +static bool js_new_cc_IGeometricInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IGeometricInfo *result; + result = (cc::IGeometricInfo *)new cc::IGeometricInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IGeometricInfo, __jsb_cc_IGeometricInfo_class, js_delete_cc_IGeometricInfo) + +static bool js_delete_cc_IGeometricInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IGeometricInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometricInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("indices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices), ctx); + } + + + json->getProperty("doubleSided", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->doubleSided), ctx); + } + + + json->getProperty("boundingBox", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->boundingBox), ctx); + } + + + return ok; +} + + +bool js_register_cc_IGeometricInfo(se::Object* obj) { + auto* cls = se::Class::create("IGeometricInfo", obj, nullptr, _SE(js_new_cc_IGeometricInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("positions", _SE(js_cc_IGeometricInfo_positions_get), _SE(js_cc_IGeometricInfo_positions_set)); + cls->defineProperty("indices", _SE(js_cc_IGeometricInfo_indices_get), _SE(js_cc_IGeometricInfo_indices_set)); + cls->defineProperty("doubleSided", _SE(js_cc_IGeometricInfo_doubleSided_get), _SE(js_cc_IGeometricInfo_doubleSided_set)); + cls->defineProperty("boundingBox", _SE(js_cc_IGeometricInfo_boundingBox_get), _SE(js_cc_IGeometricInfo_boundingBox_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IGeometricInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IGeometricInfo_proto = cls->getProto(); + __jsb_cc_IGeometricInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IFlatBuffer_class = nullptr; +se::Object* __jsb_cc_IFlatBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IFlatBuffer) + +static bool js_cc_IFlatBuffer_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IFlatBuffer_stride_set) + +static bool js_cc_IFlatBuffer_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IFlatBuffer_stride_get) + +static bool js_cc_IFlatBuffer_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IFlatBuffer_count_set) + +static bool js_cc_IFlatBuffer_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IFlatBuffer_count_get) + +static bool js_cc_IFlatBuffer_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IFlatBuffer_buffer_set) + +static bool js_cc_IFlatBuffer_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IFlatBuffer_buffer_get) + +static bool js_new_cc_IFlatBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IFlatBuffer *result; + result = (cc::IFlatBuffer *)new cc::IFlatBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IFlatBuffer, __jsb_cc_IFlatBuffer_class, js_delete_cc_IFlatBuffer) + +static bool js_delete_cc_IFlatBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IFlatBuffer) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IFlatBuffer * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + return ok; +} + + +bool js_register_cc_IFlatBuffer(se::Object* obj) { + auto* cls = se::Class::create("IFlatBuffer", obj, nullptr, _SE(js_new_cc_IFlatBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("stride", _SE(js_cc_IFlatBuffer_stride_get), _SE(js_cc_IFlatBuffer_stride_set)); + cls->defineProperty("count", _SE(js_cc_IFlatBuffer_count_get), _SE(js_cc_IFlatBuffer_count_set)); + cls->defineProperty("buffer", _SE(js_cc_IFlatBuffer_buffer_get), _SE(js_cc_IFlatBuffer_buffer_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IFlatBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IFlatBuffer_proto = cls->getProto(); + __jsb_cc_IFlatBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderingSubMesh_class = nullptr; +se::Object* __jsb_cc_RenderingSubMesh_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderingSubMesh) + +static bool js_new_cc_RenderingSubMesh__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::Buffer *arg4 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::Buffer *arg4 = (cc::gfx::Buffer *) NULL ; + cc::gfx::Buffer *arg5 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::Buffer *arg4 = (cc::gfx::Buffer *) NULL ; + cc::gfx::Buffer *arg5 = (cc::gfx::Buffer *) NULL ; + bool arg6 ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_cc_RenderingSubMesh__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_RenderingSubMesh__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_RenderingSubMesh__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 6) { + ret = js_new_cc_RenderingSubMesh__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of RenderingSubMesh"); + return false; +} +SE_BIND_CTOR(js_new_cc_RenderingSubMesh, __jsb_cc_RenderingSubMesh_class, js_delete_cc_RenderingSubMesh) + +static bool js_delete_cc_RenderingSubMesh(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderingSubMesh) + +static bool js_cc_RenderingSubMesh_getAttributes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::AttributeList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::AttributeList *) &((cc::RenderingSubMesh const *)arg1)->getAttributes(); + + 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_RenderingSubMesh_getAttributes) + +static bool js_cc_RenderingSubMesh_getVertexBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::BufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &((cc::RenderingSubMesh const *)arg1)->getVertexBuffers(); + + 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_RenderingSubMesh_getVertexBuffers) + +static bool js_cc_RenderingSubMesh_getIndexBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::RenderingSubMesh const *)arg1)->getIndexBuffer(); + + 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_RenderingSubMesh_getIndexBuffer) + +static bool js_cc_RenderingSubMesh_indirectBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::RenderingSubMesh const *)arg1)->indirectBuffer(); + + 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_RenderingSubMesh_indirectBuffer) + +static bool js_cc_RenderingSubMesh_getGeometricInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::IGeometricInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::IGeometricInfo *) &(arg1)->getGeometricInfo(); + + 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_RenderingSubMesh_getGeometricInfo) + +static bool js_cc_RenderingSubMesh_invalidateGeometricInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidateGeometricInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_invalidateGeometricInfo) + +static bool js_cc_RenderingSubMesh_genFlatBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->genFlatBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_genFlatBuffers) + +static bool js_cc_RenderingSubMesh_setDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::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(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)->setDrawInfo((cc::gfx::DrawInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_setDrawInfo) + +static bool js_cc_RenderingSubMesh_getDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::optional< cc::gfx::DrawInfo > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< cc::gfx::DrawInfo > *) &(arg1)->getDrawInfo(); + + 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_RenderingSubMesh_getDrawInfo) + +static bool js_cc_RenderingSubMesh_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) 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(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_RenderingSubMesh_destroy) + +static bool js_cc_RenderingSubMesh_enableVertexIdChannel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableVertexIdChannel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_enableVertexIdChannel) + +static bool js_cc_RenderingSubMesh_mesh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderingSubMesh_mesh_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh_mesh_set) + +static bool js_cc_RenderingSubMesh_mesh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::Mesh *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mesh *)cc_RenderingSubMesh_mesh_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_RenderingSubMesh_mesh_get) + +static bool js_cc_RenderingSubMesh_subMeshIdx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::optional< uint32_t > *arg2 = 0 ; + ccstd::optional< uint32_t > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_RenderingSubMesh_subMeshIdx_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh_subMeshIdx_set) + +static bool js_cc_RenderingSubMesh_subMeshIdx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::optional< uint32_t > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< uint32_t > *) &cc_RenderingSubMesh_subMeshIdx_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_RenderingSubMesh_subMeshIdx_get) + +static bool js_cc_RenderingSubMesh_flatBuffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *arg2 = 0 ; + ccstd::vector< cc::IFlatBuffer > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_RenderingSubMesh_flatBuffers_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh_flatBuffers_set) + +static bool js_cc_RenderingSubMesh_flatBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IFlatBuffer > *) &cc_RenderingSubMesh_flatBuffers_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_RenderingSubMesh_flatBuffers_get) + +static bool js_cc_RenderingSubMesh__flatBuffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *arg2 = 0 ; + ccstd::vector< cc::IFlatBuffer > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_RenderingSubMesh__flatBuffers_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh__flatBuffers_set) + +static bool js_cc_RenderingSubMesh__flatBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IFlatBuffer > *) &cc_RenderingSubMesh__flatBuffers_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_RenderingSubMesh__flatBuffers_get) + +static bool js_cc_RenderingSubMesh_jointMappedBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::BufferList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &cc_RenderingSubMesh_jointMappedBuffers_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_RenderingSubMesh_jointMappedBuffers_get) + +static bool js_cc_RenderingSubMesh_iaInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::InputAssemblerInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssemblerInfo *) &cc_RenderingSubMesh_iaInfo_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_RenderingSubMesh_iaInfo_get) + +static bool js_cc_RenderingSubMesh__iaInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::InputAssemblerInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssemblerInfo *) &cc_RenderingSubMesh__iaInfo_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_RenderingSubMesh__iaInfo_get) + +static bool js_cc_RenderingSubMesh_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::PrimitiveMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PrimitiveMode)cc_RenderingSubMesh_primitiveMode_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_RenderingSubMesh_primitiveMode_get) + +bool js_register_cc_RenderingSubMesh(se::Object* obj) { + auto* cls = se::Class::create("RenderingSubMesh", obj, nullptr, _SE(js_new_cc_RenderingSubMesh)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mesh", _SE(js_cc_RenderingSubMesh_mesh_get), _SE(js_cc_RenderingSubMesh_mesh_set)); + cls->defineProperty("subMeshIdx", _SE(js_cc_RenderingSubMesh_subMeshIdx_get), _SE(js_cc_RenderingSubMesh_subMeshIdx_set)); + cls->defineProperty("flatBuffers", _SE(js_cc_RenderingSubMesh_flatBuffers_get), _SE(js_cc_RenderingSubMesh_flatBuffers_set)); + cls->defineProperty("_flatBuffers", _SE(js_cc_RenderingSubMesh__flatBuffers_get), _SE(js_cc_RenderingSubMesh__flatBuffers_set)); + cls->defineProperty("jointMappedBuffers", _SE(js_cc_RenderingSubMesh_jointMappedBuffers_get), nullptr); + cls->defineProperty("iaInfo", _SE(js_cc_RenderingSubMesh_iaInfo_get), nullptr); + cls->defineProperty("_iaInfo", _SE(js_cc_RenderingSubMesh__iaInfo_get), nullptr); + cls->defineProperty("primitiveMode", _SE(js_cc_RenderingSubMesh_primitiveMode_get), nullptr); + + cls->defineFunction("getAttributes", _SE(js_cc_RenderingSubMesh_getAttributes)); + cls->defineFunction("getVertexBuffers", _SE(js_cc_RenderingSubMesh_getVertexBuffers)); + cls->defineFunction("getIndexBuffer", _SE(js_cc_RenderingSubMesh_getIndexBuffer)); + cls->defineFunction("indirectBuffer", _SE(js_cc_RenderingSubMesh_indirectBuffer)); + cls->defineFunction("getGeometricInfo", _SE(js_cc_RenderingSubMesh_getGeometricInfo)); + cls->defineFunction("invalidateGeometricInfo", _SE(js_cc_RenderingSubMesh_invalidateGeometricInfo)); + cls->defineFunction("genFlatBuffers", _SE(js_cc_RenderingSubMesh_genFlatBuffers)); + cls->defineFunction("setDrawInfo", _SE(js_cc_RenderingSubMesh_setDrawInfo)); + cls->defineFunction("getDrawInfo", _SE(js_cc_RenderingSubMesh_getDrawInfo)); + cls->defineFunction("destroy", _SE(js_cc_RenderingSubMesh_destroy)); + cls->defineFunction("enableVertexIdChannel", _SE(js_cc_RenderingSubMesh_enableVertexIdChannel)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderingSubMesh)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderingSubMesh_proto = cls->getProto(); + __jsb_cc_RenderingSubMesh_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BuiltinResMgr_class = nullptr; +se::Object* __jsb_cc_BuiltinResMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BuiltinResMgr) + +static bool js_cc_BuiltinResMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::BuiltinResMgr *)cc::BuiltinResMgr::getInstance(); + + 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_BuiltinResMgr_getInstance_static) + +static bool js_new_cc_BuiltinResMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BuiltinResMgr *result; + result = (cc::BuiltinResMgr *)new cc::BuiltinResMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BuiltinResMgr, __jsb_cc_BuiltinResMgr_class, js_delete_cc_BuiltinResMgr) + +static bool js_delete_cc_BuiltinResMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BuiltinResMgr) + +static bool js_cc_BuiltinResMgr_initBuiltinRes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->initBuiltinRes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_BuiltinResMgr_initBuiltinRes) + +static bool js_cc_BuiltinResMgr_isInitialized(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::BuiltinResMgr const *)arg1)->isInitialized(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_BuiltinResMgr_isInitialized) + +static bool js_cc_BuiltinResMgr_addAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Asset *arg3 = (cc::Asset *) 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(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)->addAsset((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_BuiltinResMgr_addAsset) + +static bool js_cc_BuiltinResMgr_getAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Asset *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(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::Asset *)(arg1)->getAsset((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_BuiltinResMgr_getAsset) + +bool js_register_cc_BuiltinResMgr(se::Object* obj) { + auto* cls = se::Class::create("BuiltinResMgr", obj, nullptr, _SE(js_new_cc_BuiltinResMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initBuiltinRes", _SE(js_cc_BuiltinResMgr_initBuiltinRes)); + cls->defineFunction("isInitialized", _SE(js_cc_BuiltinResMgr_isInitialized)); + cls->defineFunction("addAsset", _SE(js_cc_BuiltinResMgr_addAsset)); + cls->defineFunction("getAsset", _SE(js_cc_BuiltinResMgr_getAsset)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_BuiltinResMgr_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BuiltinResMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BuiltinResMgr_proto = cls->getProto(); + __jsb_cc_BuiltinResMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMeshBufferView_class = nullptr; +se::Object* __jsb_cc_IMeshBufferView_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMeshBufferView) + +static bool js_cc_IMeshBufferView_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_offset_set) + +static bool js_cc_IMeshBufferView_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_offset_get) + +static bool js_cc_IMeshBufferView_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->length, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_length_set) + +static bool js_cc_IMeshBufferView_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->length, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_length_get) + +static bool js_cc_IMeshBufferView_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_count_set) + +static bool js_cc_IMeshBufferView_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_count_get) + +static bool js_cc_IMeshBufferView_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_stride_set) + +static bool js_cc_IMeshBufferView_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_stride_get) + +static bool js_new_cc_IMeshBufferView(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMeshBufferView *result; + result = (cc::IMeshBufferView *)new cc::IMeshBufferView(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMeshBufferView, __jsb_cc_IMeshBufferView_class, js_delete_cc_IMeshBufferView) + +static bool js_delete_cc_IMeshBufferView(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMeshBufferView) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMeshBufferView * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("length", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->length), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMeshBufferView(se::Object* obj) { + auto* cls = se::Class::create("IMeshBufferView", obj, nullptr, _SE(js_new_cc_IMeshBufferView)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("offset", _SE(js_cc_IMeshBufferView_offset_get), _SE(js_cc_IMeshBufferView_offset_set)); + cls->defineProperty("length", _SE(js_cc_IMeshBufferView_length_get), _SE(js_cc_IMeshBufferView_length_set)); + cls->defineProperty("count", _SE(js_cc_IMeshBufferView_count_get), _SE(js_cc_IMeshBufferView_count_set)); + cls->defineProperty("stride", _SE(js_cc_IMeshBufferView_stride_get), _SE(js_cc_IMeshBufferView_stride_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMeshBufferView)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMeshBufferView_proto = cls->getProto(); + __jsb_cc_IMeshBufferView_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphTarget_class = nullptr; +se::Object* __jsb_cc_MorphTarget_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphTarget) + +static bool js_cc_MorphTarget_displacements_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphTarget *arg1 = (cc::MorphTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displacements, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MorphTarget_displacements_set) + +static bool js_cc_MorphTarget_displacements_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MorphTarget *arg1 = (cc::MorphTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displacements, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->displacements, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_MorphTarget_displacements_get) + +static bool js_new_cc_MorphTarget(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MorphTarget *result; + result = (cc::MorphTarget *)new cc::MorphTarget(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MorphTarget, __jsb_cc_MorphTarget_class, js_delete_cc_MorphTarget) + +static bool js_delete_cc_MorphTarget(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphTarget) + +template<> +bool sevalue_to_native(const se::Value &from, cc::MorphTarget * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("displacements", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->displacements), ctx); + } + + + return ok; +} + + +bool js_register_cc_MorphTarget(se::Object* obj) { + auto* cls = se::Class::create("MorphTarget", obj, nullptr, _SE(js_new_cc_MorphTarget)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("displacements", _SE(js_cc_MorphTarget_displacements_get), _SE(js_cc_MorphTarget_displacements_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphTarget)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphTarget_proto = cls->getProto(); + __jsb_cc_MorphTarget_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SubMeshMorph_class = nullptr; +se::Object* __jsb_cc_SubMeshMorph_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SubMeshMorph) + +static bool js_cc_SubMeshMorph_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_SubMeshMorph_attributes_set) + +static bool js_cc_SubMeshMorph_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_SubMeshMorph_attributes_get) + +static bool js_cc_SubMeshMorph_targets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_SubMeshMorph_targets_set) + +static bool js_cc_SubMeshMorph_targets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targets, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targets, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_SubMeshMorph_targets_get) + +static bool js_cc_SubMeshMorph_weights_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->weights, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_SubMeshMorph_weights_set) + +static bool js_cc_SubMeshMorph_weights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->weights, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->weights, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_SubMeshMorph_weights_get) + +static bool js_new_cc_SubMeshMorph(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SubMeshMorph *result; + result = (cc::SubMeshMorph *)new cc::SubMeshMorph(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SubMeshMorph, __jsb_cc_SubMeshMorph_class, js_delete_cc_SubMeshMorph) + +static bool js_delete_cc_SubMeshMorph(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SubMeshMorph) + +template<> +bool sevalue_to_native(const se::Value &from, cc::SubMeshMorph * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("targets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targets), ctx); + } + + + json->getProperty("weights", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->weights), ctx); + } + + + return ok; +} + + +bool js_register_cc_SubMeshMorph(se::Object* obj) { + auto* cls = se::Class::create("SubMeshMorph", obj, nullptr, _SE(js_new_cc_SubMeshMorph)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attributes", _SE(js_cc_SubMeshMorph_attributes_get), _SE(js_cc_SubMeshMorph_attributes_set)); + cls->defineProperty("targets", _SE(js_cc_SubMeshMorph_targets_get), _SE(js_cc_SubMeshMorph_targets_set)); + cls->defineProperty("weights", _SE(js_cc_SubMeshMorph_weights_get), _SE(js_cc_SubMeshMorph_weights_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SubMeshMorph)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SubMeshMorph_proto = cls->getProto(); + __jsb_cc_SubMeshMorph_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Morph_class = nullptr; +se::Object* __jsb_cc_Morph_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Morph) + +static bool js_cc_Morph_subMeshMorphs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subMeshMorphs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Morph_subMeshMorphs_set) + +static bool js_cc_Morph_subMeshMorphs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subMeshMorphs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subMeshMorphs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Morph_subMeshMorphs_get) + +static bool js_cc_Morph_weights_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->weights, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Morph_weights_set) + +static bool js_cc_Morph_weights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->weights, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->weights, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Morph_weights_get) + +static bool js_cc_Morph_targetNames_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targetNames, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Morph_targetNames_set) + +static bool js_cc_Morph_targetNames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targetNames, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targetNames, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Morph_targetNames_get) + +static bool js_new_cc_Morph(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Morph *result; + result = (cc::Morph *)new cc::Morph(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Morph, __jsb_cc_Morph_class, js_delete_cc_Morph) + +static bool js_delete_cc_Morph(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Morph) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Morph * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("subMeshMorphs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subMeshMorphs), ctx); + } + + + json->getProperty("weights", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->weights), ctx); + } + + + json->getProperty("targetNames", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targetNames), ctx); + } + + + return ok; +} + + +bool js_register_cc_Morph(se::Object* obj) { + auto* cls = se::Class::create("Morph", obj, nullptr, _SE(js_new_cc_Morph)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("subMeshMorphs", _SE(js_cc_Morph_subMeshMorphs_get), _SE(js_cc_Morph_subMeshMorphs_set)); + cls->defineProperty("weights", _SE(js_cc_Morph_weights_get), _SE(js_cc_Morph_weights_set)); + cls->defineProperty("targetNames", _SE(js_cc_Morph_targetNames_get), _SE(js_cc_Morph_targetNames_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Morph)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Morph_proto = cls->getProto(); + __jsb_cc_Morph_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphRenderingInstance_class = nullptr; +se::Object* __jsb_cc_MorphRenderingInstance_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphRenderingInstance) + +static bool js_delete_cc_MorphRenderingInstance(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphRenderingInstance) + +static bool js_cc_MorphRenderingInstance_setWeights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + index_t arg2 ; + cc::MeshWeightsType *arg3 = 0 ; + cc::MeshWeightsType temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setWeights(arg2,(cc::MeshWeightsType const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_setWeights) + +static bool js_cc_MorphRenderingInstance_adaptPipelineState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->adaptPipelineState(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_adaptPipelineState) + +static bool js_cc_MorphRenderingInstance_requiredPatches(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + index_t arg2 ; + ccstd::vector< cc::scene::IMacroPatch > result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->requiredPatches(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_requiredPatches) + +static bool js_cc_MorphRenderingInstance_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_destroy) + +bool js_register_cc_MorphRenderingInstance(se::Object* obj) { + auto* cls = se::Class::create("MorphRenderingInstance", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setWeights", _SE(js_cc_MorphRenderingInstance_setWeights)); + cls->defineFunction("adaptPipelineState", _SE(js_cc_MorphRenderingInstance_adaptPipelineState)); + cls->defineFunction("requiredPatches", _SE(js_cc_MorphRenderingInstance_requiredPatches)); + cls->defineFunction("destroy", _SE(js_cc_MorphRenderingInstance_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphRenderingInstance)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphRenderingInstance_proto = cls->getProto(); + __jsb_cc_MorphRenderingInstance_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphRendering_class = nullptr; +se::Object* __jsb_cc_MorphRendering_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphRendering) + +static bool js_delete_cc_MorphRendering(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphRendering) + +static bool js_cc_MorphRendering_createInstance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRendering *arg1 = (cc::MorphRendering *) NULL ; + cc::MorphRenderingInstance *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(s); + if (nullptr == arg1) return true; + result = (cc::MorphRenderingInstance *)(arg1)->createInstance(); + + 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_MorphRendering_createInstance) + +bool js_register_cc_MorphRendering(se::Object* obj) { + auto* cls = se::Class::create("MorphRendering", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("createInstance", _SE(js_cc_MorphRendering_createInstance)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphRendering)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphRendering_proto = cls->getProto(); + __jsb_cc_MorphRendering_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_StdMorphRendering_class = nullptr; +se::Object* __jsb_cc_StdMorphRendering_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_StdMorphRendering) + +static bool js_new_cc_StdMorphRendering(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::StdMorphRendering *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::StdMorphRendering *)new cc::StdMorphRendering(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_StdMorphRendering, __jsb_cc_StdMorphRendering_class, js_delete_cc_StdMorphRendering) + +static bool js_delete_cc_StdMorphRendering(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_StdMorphRendering) + +bool js_register_cc_StdMorphRendering(se::Object* obj) { + auto* cls = se::Class::create("StdMorphRendering", obj, __jsb_cc_MorphRendering_proto, _SE(js_new_cc_StdMorphRendering)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_StdMorphRendering)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_StdMorphRendering_proto = cls->getProto(); + __jsb_cc_StdMorphRendering_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_createMorphRendering(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::MorphRendering *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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::MorphRendering *)cc::createMorphRendering(arg1,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_createMorphRendering) + +se::Class* __jsb_cc_Mesh_class = nullptr; +se::Object* __jsb_cc_Mesh_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh) + +se::Class* __jsb_cc_Mesh_IVertexBundle_class = nullptr; +se::Object* __jsb_cc_Mesh_IVertexBundle_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IVertexBundle) + +static bool js_cc_Mesh_IVertexBundle__padding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_padding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IVertexBundle__padding_set) + +static bool js_cc_Mesh_IVertexBundle__padding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_padding, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_padding, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IVertexBundle__padding_get) + +static bool js_cc_Mesh_IVertexBundle_view_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->view, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IVertexBundle_view_set) + +static bool js_cc_Mesh_IVertexBundle_view_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->view, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->view, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IVertexBundle_view_get) + +static bool js_cc_Mesh_IVertexBundle_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IVertexBundle_attributes_set) + +static bool js_cc_Mesh_IVertexBundle_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IVertexBundle_attributes_get) + +static bool js_new_cc_Mesh_IVertexBundle(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IVertexBundle *result; + result = (cc::Mesh::IVertexBundle *)new cc::Mesh::IVertexBundle(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IVertexBundle, __jsb_cc_Mesh_IVertexBundle_class, js_delete_cc_Mesh_IVertexBundle) + +static bool js_delete_cc_Mesh_IVertexBundle(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IVertexBundle) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IVertexBundle * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("_padding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_padding), ctx); + } + + + json->getProperty("view", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->view), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IVertexBundle(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IVertexBundle"}, obj, nullptr, _SE(js_new_cc_Mesh_IVertexBundle)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_padding", _SE(js_cc_Mesh_IVertexBundle__padding_get), _SE(js_cc_Mesh_IVertexBundle__padding_set)); + cls->defineProperty("view", _SE(js_cc_Mesh_IVertexBundle_view_get), _SE(js_cc_Mesh_IVertexBundle_view_set)); + cls->defineProperty("attributes", _SE(js_cc_Mesh_IVertexBundle_attributes_get), _SE(js_cc_Mesh_IVertexBundle_attributes_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IVertexBundle)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IVertexBundle_proto = cls->getProto(); + __jsb_cc_Mesh_IVertexBundle_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IMeshCluster_class = nullptr; +se::Object* __jsb_cc_Mesh_IMeshCluster_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IMeshCluster) + +static bool js_cc_Mesh_IMeshCluster_clusterView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->clusterView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_clusterView_set) + +static bool js_cc_Mesh_IMeshCluster_clusterView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->clusterView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->clusterView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_clusterView_get) + +static bool js_cc_Mesh_IMeshCluster_triangleView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->triangleView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_triangleView_set) + +static bool js_cc_Mesh_IMeshCluster_triangleView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->triangleView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->triangleView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_triangleView_get) + +static bool js_cc_Mesh_IMeshCluster_vertexView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_vertexView_set) + +static bool js_cc_Mesh_IMeshCluster_vertexView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_vertexView_get) + +static bool js_cc_Mesh_IMeshCluster_coneView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->coneView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_coneView_set) + +static bool js_cc_Mesh_IMeshCluster_coneView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->coneView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->coneView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_coneView_get) + +static bool js_new_cc_Mesh_IMeshCluster(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IMeshCluster *result; + result = (cc::Mesh::IMeshCluster *)new cc::Mesh::IMeshCluster(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IMeshCluster, __jsb_cc_Mesh_IMeshCluster_class, js_delete_cc_Mesh_IMeshCluster) + +static bool js_delete_cc_Mesh_IMeshCluster(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IMeshCluster) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IMeshCluster * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("clusterView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->clusterView), ctx); + } + + + json->getProperty("triangleView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->triangleView), ctx); + } + + + json->getProperty("vertexView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexView), ctx); + } + + + json->getProperty("coneView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->coneView), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IMeshCluster(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IMeshCluster"}, obj, nullptr, _SE(js_new_cc_Mesh_IMeshCluster)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("clusterView", _SE(js_cc_Mesh_IMeshCluster_clusterView_get), _SE(js_cc_Mesh_IMeshCluster_clusterView_set)); + cls->defineProperty("triangleView", _SE(js_cc_Mesh_IMeshCluster_triangleView_get), _SE(js_cc_Mesh_IMeshCluster_triangleView_set)); + cls->defineProperty("vertexView", _SE(js_cc_Mesh_IMeshCluster_vertexView_get), _SE(js_cc_Mesh_IMeshCluster_vertexView_set)); + cls->defineProperty("coneView", _SE(js_cc_Mesh_IMeshCluster_coneView_get), _SE(js_cc_Mesh_IMeshCluster_coneView_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IMeshCluster)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IMeshCluster_proto = cls->getProto(); + __jsb_cc_Mesh_IMeshCluster_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_ISubMesh_class = nullptr; +se::Object* __jsb_cc_Mesh_ISubMesh_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_ISubMesh) + +static bool js_cc_Mesh_ISubMesh_vertexBundelIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexBundelIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_vertexBundelIndices_set) + +static bool js_cc_Mesh_ISubMesh_vertexBundelIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexBundelIndices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexBundelIndices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_vertexBundelIndices_get) + +static bool js_cc_Mesh_ISubMesh_primitiveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitiveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_primitiveMode_set) + +static bool js_cc_Mesh_ISubMesh_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitiveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitiveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_primitiveMode_get) + +static bool js_cc_Mesh_ISubMesh_indexView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_indexView_set) + +static bool js_cc_Mesh_ISubMesh_indexView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_indexView_get) + +static bool js_cc_Mesh_ISubMesh_jointMapIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->jointMapIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_jointMapIndex_set) + +static bool js_cc_Mesh_ISubMesh_jointMapIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->jointMapIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->jointMapIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_jointMapIndex_get) + +static bool js_cc_Mesh_ISubMesh_cluster_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cluster, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_cluster_set) + +static bool js_cc_Mesh_ISubMesh_cluster_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cluster, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cluster, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_cluster_get) + +static bool js_new_cc_Mesh_ISubMesh(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::ISubMesh *result; + result = (cc::Mesh::ISubMesh *)new cc::Mesh::ISubMesh(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_ISubMesh, __jsb_cc_Mesh_ISubMesh_class, js_delete_cc_Mesh_ISubMesh) + +static bool js_delete_cc_Mesh_ISubMesh(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_ISubMesh) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ISubMesh * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vertexBundelIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexBundelIndices), ctx); + } + + + json->getProperty("primitiveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitiveMode), ctx); + } + + + json->getProperty("indexView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexView), ctx); + } + + + json->getProperty("jointMapIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->jointMapIndex), ctx); + } + + + json->getProperty("cluster", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cluster), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_ISubMesh(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "ISubMesh"}, obj, nullptr, _SE(js_new_cc_Mesh_ISubMesh)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexBundelIndices", _SE(js_cc_Mesh_ISubMesh_vertexBundelIndices_get), _SE(js_cc_Mesh_ISubMesh_vertexBundelIndices_set)); + cls->defineProperty("primitiveMode", _SE(js_cc_Mesh_ISubMesh_primitiveMode_get), _SE(js_cc_Mesh_ISubMesh_primitiveMode_set)); + cls->defineProperty("indexView", _SE(js_cc_Mesh_ISubMesh_indexView_get), _SE(js_cc_Mesh_ISubMesh_indexView_set)); + cls->defineProperty("jointMapIndex", _SE(js_cc_Mesh_ISubMesh_jointMapIndex_get), _SE(js_cc_Mesh_ISubMesh_jointMapIndex_set)); + cls->defineProperty("cluster", _SE(js_cc_Mesh_ISubMesh_cluster_get), _SE(js_cc_Mesh_ISubMesh_cluster_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_ISubMesh)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_ISubMesh_proto = cls->getProto(); + __jsb_cc_Mesh_ISubMesh_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IDynamicInfo_class = nullptr; +se::Object* __jsb_cc_Mesh_IDynamicInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicInfo) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicInfo_maxSubMeshes_set) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicInfo_maxSubMeshes_get) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshVertices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_set) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshVertices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_get) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_set) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshIndices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_get) + +static bool js_new_cc_Mesh_IDynamicInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IDynamicInfo *result; + result = (cc::Mesh::IDynamicInfo *)new cc::Mesh::IDynamicInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IDynamicInfo, __jsb_cc_Mesh_IDynamicInfo_class, js_delete_cc_Mesh_IDynamicInfo) + +static bool js_delete_cc_Mesh_IDynamicInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxSubMeshes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshes), ctx); + } + + + json->getProperty("maxSubMeshVertices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshVertices), ctx); + } + + + json->getProperty("maxSubMeshIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshIndices), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IDynamicInfo(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IDynamicInfo"}, obj, nullptr, _SE(js_new_cc_Mesh_IDynamicInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxSubMeshes", _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshes_get), _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshes_set)); + cls->defineProperty("maxSubMeshVertices", _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_get), _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_set)); + cls->defineProperty("maxSubMeshIndices", _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_get), _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IDynamicInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IDynamicInfo_proto = cls->getProto(); + __jsb_cc_Mesh_IDynamicInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IDynamicStruct_class = nullptr; +se::Object* __jsb_cc_Mesh_IDynamicStruct_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicStruct) + +static bool js_cc_Mesh_IDynamicStruct_info_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->info, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicStruct_info_set) + +static bool js_cc_Mesh_IDynamicStruct_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->info, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->info, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicStruct_info_get) + +static bool js_cc_Mesh_IDynamicStruct_bounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicStruct_bounds_set) + +static bool js_cc_Mesh_IDynamicStruct_bounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bounds, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bounds, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicStruct_bounds_get) + +static bool js_new_cc_Mesh_IDynamicStruct(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IDynamicStruct *result; + result = (cc::Mesh::IDynamicStruct *)new cc::Mesh::IDynamicStruct(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IDynamicStruct, __jsb_cc_Mesh_IDynamicStruct_class, js_delete_cc_Mesh_IDynamicStruct) + +static bool js_delete_cc_Mesh_IDynamicStruct(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicStruct) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicStruct * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("info", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->info), ctx); + } + + + json->getProperty("bounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bounds), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IDynamicStruct(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IDynamicStruct"}, obj, nullptr, _SE(js_new_cc_Mesh_IDynamicStruct)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("info", _SE(js_cc_Mesh_IDynamicStruct_info_get), _SE(js_cc_Mesh_IDynamicStruct_info_set)); + cls->defineProperty("bounds", _SE(js_cc_Mesh_IDynamicStruct_bounds_get), _SE(js_cc_Mesh_IDynamicStruct_bounds_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IDynamicStruct)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IDynamicStruct_proto = cls->getProto(); + __jsb_cc_Mesh_IDynamicStruct_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IStruct_class = nullptr; +se::Object* __jsb_cc_Mesh_IStruct_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IStruct) + +static bool js_cc_Mesh_IStruct_vertexBundles_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexBundles, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_vertexBundles_set) + +static bool js_cc_Mesh_IStruct_vertexBundles_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexBundles, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexBundles, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_vertexBundles_get) + +static bool js_cc_Mesh_IStruct_primitives_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitives, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_primitives_set) + +static bool js_cc_Mesh_IStruct_primitives_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitives, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitives, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_primitives_get) + +static bool js_cc_Mesh_IStruct_minPosition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minPosition, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_minPosition_set) + +static bool js_cc_Mesh_IStruct_minPosition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minPosition, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minPosition, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_minPosition_get) + +static bool js_cc_Mesh_IStruct_getMinPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< cc::Vec3 > *) &((cc::Mesh::IStruct const *)arg1)->getMinPosition(); + + 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_Mesh_IStruct_getMinPosition) + +static bool js_cc_Mesh_IStruct_setMinPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *arg2 = 0 ; + ccstd::optional< cc::Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMinPosition((ccstd::optional< cc::Vec3 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_IStruct_setMinPosition) + +static bool js_cc_Mesh_IStruct_maxPosition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxPosition, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_maxPosition_set) + +static bool js_cc_Mesh_IStruct_maxPosition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxPosition, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxPosition, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_maxPosition_get) + +static bool js_cc_Mesh_IStruct_getMaxPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< cc::Vec3 > *) &((cc::Mesh::IStruct const *)arg1)->getMaxPosition(); + + 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_Mesh_IStruct_getMaxPosition) + +static bool js_cc_Mesh_IStruct_setMaxPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *arg2 = 0 ; + ccstd::optional< cc::Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMaxPosition((ccstd::optional< cc::Vec3 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_IStruct_setMaxPosition) + +static bool js_cc_Mesh_IStruct_jointMaps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->jointMaps, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_jointMaps_set) + +static bool js_cc_Mesh_IStruct_jointMaps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->jointMaps, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->jointMaps, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_jointMaps_get) + +static bool js_cc_Mesh_IStruct_morph_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->morph, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_morph_set) + +static bool js_cc_Mesh_IStruct_morph_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->morph, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->morph, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_morph_get) + +static bool js_cc_Mesh_IStruct_dynamic_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamic, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_dynamic_set) + +static bool js_cc_Mesh_IStruct_dynamic_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamic, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamic, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_dynamic_get) + +static bool js_cc_Mesh_IStruct_encoded_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->encoded, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_encoded_set) + +static bool js_cc_Mesh_IStruct_encoded_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->encoded, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->encoded, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_encoded_get) + +static bool js_cc_Mesh_IStruct_compressed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compressed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_compressed_set) + +static bool js_cc_Mesh_IStruct_compressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compressed, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->compressed, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_compressed_get) + +static bool js_cc_Mesh_IStruct_quantized_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->quantized, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_quantized_set) + +static bool js_cc_Mesh_IStruct_quantized_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->quantized, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->quantized, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_quantized_get) + +static bool js_new_cc_Mesh_IStruct(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IStruct *result; + result = (cc::Mesh::IStruct *)new cc::Mesh::IStruct(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IStruct, __jsb_cc_Mesh_IStruct_class, js_delete_cc_Mesh_IStruct) + +static bool js_delete_cc_Mesh_IStruct(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IStruct) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IStruct * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vertexBundles", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexBundles), ctx); + } + + + json->getProperty("primitives", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitives), ctx); + } + + + json->getProperty("minPosition", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minPosition), ctx); + } + + + json->getProperty("maxPosition", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxPosition), ctx); + } + + + json->getProperty("jointMaps", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->jointMaps), ctx); + } + + + json->getProperty("morph", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->morph), ctx); + } + + + json->getProperty("dynamic", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamic), ctx); + } + + + json->getProperty("encoded", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->encoded), ctx); + } + + + json->getProperty("compressed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compressed), ctx); + } + + + json->getProperty("quantized", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->quantized), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IStruct(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IStruct"}, obj, nullptr, _SE(js_new_cc_Mesh_IStruct)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexBundles", _SE(js_cc_Mesh_IStruct_vertexBundles_get), _SE(js_cc_Mesh_IStruct_vertexBundles_set)); + cls->defineProperty("primitives", _SE(js_cc_Mesh_IStruct_primitives_get), _SE(js_cc_Mesh_IStruct_primitives_set)); + cls->defineProperty("minPosition", _SE(js_cc_Mesh_IStruct_minPosition_get), _SE(js_cc_Mesh_IStruct_minPosition_set)); + cls->defineProperty("maxPosition", _SE(js_cc_Mesh_IStruct_maxPosition_get), _SE(js_cc_Mesh_IStruct_maxPosition_set)); + cls->defineProperty("jointMaps", _SE(js_cc_Mesh_IStruct_jointMaps_get), _SE(js_cc_Mesh_IStruct_jointMaps_set)); + cls->defineProperty("morph", _SE(js_cc_Mesh_IStruct_morph_get), _SE(js_cc_Mesh_IStruct_morph_set)); + cls->defineProperty("dynamic", _SE(js_cc_Mesh_IStruct_dynamic_get), _SE(js_cc_Mesh_IStruct_dynamic_set)); + cls->defineProperty("encoded", _SE(js_cc_Mesh_IStruct_encoded_get), _SE(js_cc_Mesh_IStruct_encoded_set)); + cls->defineProperty("compressed", _SE(js_cc_Mesh_IStruct_compressed_get), _SE(js_cc_Mesh_IStruct_compressed_set)); + cls->defineProperty("quantized", _SE(js_cc_Mesh_IStruct_quantized_get), _SE(js_cc_Mesh_IStruct_quantized_set)); + + cls->defineFunction("getMinPosition", _SE(js_cc_Mesh_IStruct_getMinPosition)); + cls->defineFunction("setMinPosition", _SE(js_cc_Mesh_IStruct_setMinPosition)); + cls->defineFunction("getMaxPosition", _SE(js_cc_Mesh_IStruct_getMaxPosition)); + cls->defineFunction("setMaxPosition", _SE(js_cc_Mesh_IStruct_setMaxPosition)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IStruct)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IStruct_proto = cls->getProto(); + __jsb_cc_Mesh_IStruct_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_ICreateInfo_class = nullptr; +se::Object* __jsb_cc_Mesh_ICreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_ICreateInfo) + +static bool js_cc_Mesh_ICreateInfo_cpp_keyword_struct_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->structInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_set) + +static bool js_cc_Mesh_ICreateInfo_cpp_keyword_struct_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->structInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->structInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_get) + +static bool js_cc_Mesh_ICreateInfo_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ICreateInfo_data_set) + +static bool js_cc_Mesh_ICreateInfo_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ICreateInfo_data_get) + +static bool js_new_cc_Mesh_ICreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::ICreateInfo *result; + result = (cc::Mesh::ICreateInfo *)new cc::Mesh::ICreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_ICreateInfo, __jsb_cc_Mesh_ICreateInfo_class, js_delete_cc_Mesh_ICreateInfo) + +static bool js_delete_cc_Mesh_ICreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_ICreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ICreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("struct", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->structInfo), ctx); + } + + + json->getProperty("data", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->data), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_ICreateInfo(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "ICreateInfo"}, obj, nullptr, _SE(js_new_cc_Mesh_ICreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("struct", _SE(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_get), _SE(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_set)); + cls->defineProperty("data", _SE(js_cc_Mesh_ICreateInfo_data_get), _SE(js_cc_Mesh_ICreateInfo_data_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_ICreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_ICreateInfo_proto = cls->getProto(); + __jsb_cc_Mesh_ICreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_new_cc_Mesh(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh *result; + result = (cc::Mesh *)new cc::Mesh(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh, __jsb_cc_Mesh_class, js_delete_cc_Mesh) + +static bool js_delete_cc_Mesh(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh) + +static bool js_cc_Mesh_getMinPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *)((cc::Mesh const *)arg1)->getMinPosition(); + + 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_Mesh_getMinPosition) + +static bool js_cc_Mesh_getMaxPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *)((cc::Mesh const *)arg1)->getMaxPosition(); + + 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_Mesh_getMaxPosition) + +static bool js_cc_Mesh_getStruct(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::IStruct *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(s); + if (nullptr == arg1) return true; + result = (cc::Mesh::IStruct *) &((cc::Mesh const *)arg1)->getStruct(); + + 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_Mesh_getStruct) + +static bool js_cc_Mesh_setStruct(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::IStruct *arg2 = 0 ; + cc::Mesh::IStruct temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStruct((cc::Mesh::IStruct const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_setStruct) + +static bool js_cc_Mesh_setData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Uint8Array *arg2 = 0 ; + cc::Uint8Array temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setData((cc::Uint8Array const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_setData) + +static bool js_cc_Mesh_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_initialize) + +static bool js_cc_Mesh_destroyRenderingMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyRenderingMesh(); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_destroyRenderingMesh) + +static bool js_cc_Mesh_assign(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::IStruct *arg2 = 0 ; + cc::Uint8Array *arg3 = 0 ; + cc::Mesh::IStruct temp2 ; + cc::Uint8Array temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->assign((cc::Mesh::IStruct const &)*arg2,(cc::Uint8Array const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_assign) + +static bool js_cc_Mesh_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::ICreateInfo *arg2 = 0 ; + cc::Mesh::ICreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::Mesh::ICreateInfo &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_reset) + +static bool js_cc_Mesh_getBoneSpaceBounds(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Skeleton *arg2 = (cc::Skeleton *) NULL ; + cc::Mesh::BoneSpaceBounds result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getBoneSpaceBounds(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_getBoneSpaceBounds) + +static bool js_cc_Mesh_merge__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + cc::Mat4 *arg3 = (cc::Mat4 *) NULL ; + bool arg4 ; + cc::Mat4 temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (cc::Mat4 *) &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->merge(arg2,(cc::Mat4 const *)arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Mesh_merge__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + cc::Mat4 *arg3 = (cc::Mat4 *) NULL ; + cc::Mat4 temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (cc::Mat4 *) &temp3; + + result = (bool)(arg1)->merge(arg2,(cc::Mat4 const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Mesh_merge__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(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)->merge(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Mesh_merge(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Mesh_merge__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Mesh_merge__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Mesh_merge__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Mesh_merge) + +static bool js_cc_Mesh_validateMergingMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) 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(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)->validateMergingMesh(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_validateMergingMesh) + +static bool js_cc_Mesh_readAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + char *arg3 = (char *) NULL ; + ccstd::string temp3 ; + cc::TypedArray result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (arg1)->readAttribute(arg2,(char const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_readAttribute) + +static bool js_cc_Mesh_copyAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + char *arg3 = (char *) NULL ; + cc::ArrayBuffer *arg4 = (cc::ArrayBuffer *) NULL ; + uint32_t arg5 ; + uint32_t arg6 ; + ccstd::string temp3 ; + bool result; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + + 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 = (bool)(arg1)->copyAttribute(arg2,(char const *)arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_copyAttribute) + +static bool js_cc_Mesh_readIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + cc::IBArray result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->readIndices(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_readIndices) + +static bool js_cc_Mesh_copyIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + cc::TypedArray *arg3 = 0 ; + cc::TypedArray temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->copyIndices(arg2,*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_copyIndices) + +static bool js_cc_Mesh_readAttributeFormat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + char *arg3 = (char *) NULL ; + ccstd::string temp3 ; + cc::gfx::FormatInfo *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(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (cc::gfx::FormatInfo *)(arg1)->readAttributeFormat(arg2,(char 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_Mesh_readAttributeFormat) + +static bool js_cc_Mesh_updateSubMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + cc::IDynamicGeometry *arg3 = 0 ; + cc::IDynamicGeometry temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->updateSubMesh(arg2,(cc::IDynamicGeometry const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_updateSubMesh) + +static bool js_cc_Mesh_morphRendering_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->morphRendering, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_morphRendering_set) + +static bool js_cc_Mesh_morphRendering_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->morphRendering, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->morphRendering, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_morphRendering_get) + +static bool js_cc_Mesh__hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Mesh__hash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh__hash_set) + +static bool js_cc_Mesh__hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Mesh__hash_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_Mesh__hash_get) + +static bool js_cc_Mesh_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Mesh_hash_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_Mesh_hash_get) + +static bool js_cc_Mesh_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Uint8Array *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Uint8Array *) &cc_Mesh_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_data_get) + +static bool js_cc_Mesh__data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Uint8Array *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Uint8Array *) &cc_Mesh__data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh__data_get) + +static bool js_cc_Mesh_jointBufferIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::JointBufferIndicesType *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mesh::JointBufferIndicesType *) &cc_Mesh_jointBufferIndices_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_Mesh_jointBufferIndices_get) + +static bool js_cc_Mesh_renderingSubMeshes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::RenderingSubMeshList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mesh::RenderingSubMeshList *) &cc_Mesh_renderingSubMeshes_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_Mesh_renderingSubMeshes_get) + +static bool js_cc_Mesh_subMeshCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Mesh_subMeshCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_subMeshCount_get) + +static bool js_cc_Mesh__nativeAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::ArrayBuffer *arg2 = (cc::ArrayBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Mesh__nativeAsset_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh__nativeAsset_set) + +static bool js_cc_Mesh__nativeAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::ArrayBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)cc_Mesh__nativeAsset_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_Mesh__nativeAsset_get) + +static bool js_cc_Mesh__allowDataAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Mesh__allowDataAccess_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh__allowDataAccess_set) + +static bool js_cc_Mesh__allowDataAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Mesh__allowDataAccess_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh__allowDataAccess_get) + +static bool js_cc_Mesh_allowDataAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Mesh_allowDataAccess_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_allowDataAccess_set) + +static bool js_cc_Mesh_allowDataAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Mesh_allowDataAccess_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_allowDataAccess_get) + +bool js_register_cc_Mesh(se::Object* obj) { + auto* cls = se::Class::create("Mesh", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_Mesh)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("morphRendering", _SE(js_cc_Mesh_morphRendering_get), _SE(js_cc_Mesh_morphRendering_set)); + cls->defineProperty("_hash", _SE(js_cc_Mesh__hash_get), _SE(js_cc_Mesh__hash_set)); + cls->defineProperty("hash", _SE(js_cc_Mesh_hash_get), nullptr); + cls->defineProperty("data", _SE(js_cc_Mesh_data_get), nullptr); + cls->defineProperty("_data", _SE(js_cc_Mesh__data_get), nullptr); + cls->defineProperty("jointBufferIndices", _SE(js_cc_Mesh_jointBufferIndices_get), nullptr); + cls->defineProperty("renderingSubMeshes", _SE(js_cc_Mesh_renderingSubMeshes_get), nullptr); + cls->defineProperty("subMeshCount", _SE(js_cc_Mesh_subMeshCount_get), nullptr); + cls->defineProperty("_nativeAsset", _SE(js_cc_Mesh__nativeAsset_get), _SE(js_cc_Mesh__nativeAsset_set)); + cls->defineProperty("_allowDataAccess", _SE(js_cc_Mesh__allowDataAccess_get), _SE(js_cc_Mesh__allowDataAccess_set)); + cls->defineProperty("allowDataAccess", _SE(js_cc_Mesh_allowDataAccess_get), _SE(js_cc_Mesh_allowDataAccess_set)); + + cls->defineFunction("getMinPosition", _SE(js_cc_Mesh_getMinPosition)); + cls->defineFunction("getMaxPosition", _SE(js_cc_Mesh_getMaxPosition)); + cls->defineFunction("getStruct", _SE(js_cc_Mesh_getStruct)); + cls->defineFunction("setStruct", _SE(js_cc_Mesh_setStruct)); + cls->defineFunction("setData", _SE(js_cc_Mesh_setData)); + cls->defineFunction("initialize", _SE(js_cc_Mesh_initialize)); + cls->defineFunction("destroyRenderingMesh", _SE(js_cc_Mesh_destroyRenderingMesh)); + cls->defineFunction("assign", _SE(js_cc_Mesh_assign)); + cls->defineFunction("reset", _SE(js_cc_Mesh_reset)); + cls->defineFunction("getBoneSpaceBounds", _SE(js_cc_Mesh_getBoneSpaceBounds)); + cls->defineFunction("merge", _SE(js_cc_Mesh_merge)); + cls->defineFunction("validateMergingMesh", _SE(js_cc_Mesh_validateMergingMesh)); + cls->defineFunction("readAttribute", _SE(js_cc_Mesh_readAttribute)); + cls->defineFunction("copyAttribute", _SE(js_cc_Mesh_copyAttribute)); + cls->defineFunction("readIndices", _SE(js_cc_Mesh_readIndices)); + cls->defineFunction("copyIndices", _SE(js_cc_Mesh_copyIndices)); + cls->defineFunction("readAttributeFormat", _SE(js_cc_Mesh_readAttributeFormat)); + cls->defineFunction("updateSubMesh", _SE(js_cc_Mesh_updateSubMesh)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_proto = cls->getProto(); + __jsb_cc_Mesh_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Skeleton_class = nullptr; +se::Object* __jsb_cc_Skeleton_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Skeleton) + +static bool js_new_cc_Skeleton(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Skeleton *result; + result = (cc::Skeleton *)new cc::Skeleton(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Skeleton, __jsb_cc_Skeleton_class, js_delete_cc_Skeleton) + +static bool js_delete_cc_Skeleton(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Skeleton) + +static bool js_cc_Skeleton__getBindposes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Mat4 > *) &((cc::Skeleton const *)arg1)->getBindposes(); + + 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_Skeleton__getBindposes) + +static bool js_cc_Skeleton__setBindposes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *arg2 = 0 ; + ccstd::vector< cc::Mat4 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setBindposes((ccstd::vector< cc::Mat4 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Skeleton__setBindposes) + +static bool js_cc_Skeleton_joints_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *arg2 = 0 ; + ccstd::vector< ccstd::string > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Skeleton_joints_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton_joints_set) + +static bool js_cc_Skeleton_joints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &cc_Skeleton_joints_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_Skeleton_joints_get) + +static bool js_cc_Skeleton__joints_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *arg2 = 0 ; + ccstd::vector< ccstd::string > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Skeleton__joints_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton__joints_set) + +static bool js_cc_Skeleton__joints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &cc_Skeleton__joints_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_Skeleton__joints_get) + +static bool js_cc_Skeleton_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Skeleton_hash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton_hash_set) + +static bool js_cc_Skeleton_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Skeleton_hash_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_Skeleton_hash_get) + +static bool js_cc_Skeleton__hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Skeleton__hash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton__hash_set) + +static bool js_cc_Skeleton__hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Skeleton__hash_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_Skeleton__hash_get) + +static bool js_cc_Skeleton__invBindposes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Mat4 > *) &cc_Skeleton__invBindposes_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_Skeleton__invBindposes_get) + +static bool js_cc_Skeleton_inverseBindposes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Mat4 > *) &cc_Skeleton_inverseBindposes_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_Skeleton_inverseBindposes_get) + +bool js_register_cc_Skeleton(se::Object* obj) { + auto* cls = se::Class::create("Skeleton", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_Skeleton)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("joints", _SE(js_cc_Skeleton_joints_get), _SE(js_cc_Skeleton_joints_set)); + cls->defineProperty("_joints", _SE(js_cc_Skeleton__joints_get), _SE(js_cc_Skeleton__joints_set)); + cls->defineProperty("hash", _SE(js_cc_Skeleton_hash_get), _SE(js_cc_Skeleton_hash_set)); + cls->defineProperty("_hash", _SE(js_cc_Skeleton__hash_get), _SE(js_cc_Skeleton__hash_set)); + cls->defineProperty("_invBindposes", _SE(js_cc_Skeleton__invBindposes_get), nullptr); + cls->defineProperty("inverseBindposes", _SE(js_cc_Skeleton_inverseBindposes_get), nullptr); + + cls->defineFunction("_getBindposes", _SE(js_cc_Skeleton__getBindposes)); + cls->defineFunction("_setBindposes", _SE(js_cc_Skeleton__setBindposes)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Skeleton)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Skeleton_proto = cls->getProto(); + __jsb_cc_Skeleton_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICreateMeshOptions_class = nullptr; +se::Object* __jsb_cc_ICreateMeshOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICreateMeshOptions) + +static bool js_cc_ICreateMeshOptions_calculateBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateMeshOptions *arg1 = (cc::ICreateMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->calculateBounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateMeshOptions_calculateBounds_set) + +static bool js_cc_ICreateMeshOptions_calculateBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateMeshOptions *arg1 = (cc::ICreateMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->calculateBounds, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->calculateBounds, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateMeshOptions_calculateBounds_get) + +static bool js_new_cc_ICreateMeshOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ICreateMeshOptions *result; + result = (cc::ICreateMeshOptions *)new cc::ICreateMeshOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ICreateMeshOptions, __jsb_cc_ICreateMeshOptions_class, js_delete_cc_ICreateMeshOptions) + +static bool js_delete_cc_ICreateMeshOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICreateMeshOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateMeshOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("calculateBounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->calculateBounds), ctx); + } + + + return ok; +} + + +bool js_register_cc_ICreateMeshOptions(se::Object* obj) { + auto* cls = se::Class::create("ICreateMeshOptions", obj, nullptr, _SE(js_new_cc_ICreateMeshOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("calculateBounds", _SE(js_cc_ICreateMeshOptions_calculateBounds_get), _SE(js_cc_ICreateMeshOptions_calculateBounds_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICreateMeshOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICreateMeshOptions_proto = cls->getProto(); + __jsb_cc_ICreateMeshOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICreateDynamicMeshOptions_class = nullptr; +se::Object* __jsb_cc_ICreateDynamicMeshOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICreateDynamicMeshOptions) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_set) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_get) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshVertices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_set) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshVertices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_get) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_set) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshIndices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_get) + +static bool js_new_cc_ICreateDynamicMeshOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ICreateDynamicMeshOptions *result; + result = (cc::ICreateDynamicMeshOptions *)new cc::ICreateDynamicMeshOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ICreateDynamicMeshOptions, __jsb_cc_ICreateDynamicMeshOptions_class, js_delete_cc_ICreateDynamicMeshOptions) + +static bool js_delete_cc_ICreateDynamicMeshOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICreateDynamicMeshOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateDynamicMeshOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxSubMeshes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshes), ctx); + } + + + json->getProperty("maxSubMeshVertices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshVertices), ctx); + } + + + json->getProperty("maxSubMeshIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshIndices), ctx); + } + + + return ok; +} + + +bool js_register_cc_ICreateDynamicMeshOptions(se::Object* obj) { + auto* cls = se::Class::create("ICreateDynamicMeshOptions", obj, nullptr, _SE(js_new_cc_ICreateDynamicMeshOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxSubMeshes", _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_get), _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_set)); + cls->defineProperty("maxSubMeshVertices", _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_get), _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_set)); + cls->defineProperty("maxSubMeshIndices", _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_get), _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICreateDynamicMeshOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICreateDynamicMeshOptions_proto = cls->getProto(); + __jsb_cc_ICreateDynamicMeshOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MeshUtils_class = nullptr; +se::Object* __jsb_cc_MeshUtils_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MeshUtils) + +static bool js_cc_MeshUtils_createMesh_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IGeometry *arg1 = 0 ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + ccstd::optional< cc::ICreateMeshOptions > *arg3 = 0 ; + cc::IGeometry temp1 ; + ccstd::optional< cc::ICreateMeshOptions > temp3 ; + cc::Mesh *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::Mesh *)cc::MeshUtils::createMesh((cc::IGeometry const &)*arg1,arg2,(ccstd::optional< cc::ICreateMeshOptions > 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; +} + +static bool js_cc_MeshUtils_createMesh_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IGeometry *arg1 = 0 ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + cc::IGeometry temp1 ; + cc::Mesh *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mesh *)cc::MeshUtils::createMesh((cc::IGeometry const &)*arg1,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_MeshUtils_createMesh_static__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IGeometry *arg1 = 0 ; + cc::IGeometry temp1 ; + cc::Mesh *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mesh *)cc::MeshUtils::createMesh((cc::IGeometry const &)*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; +} + +static bool js_cc_MeshUtils_createMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_MeshUtils_createMesh_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MeshUtils_createMesh_static__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_MeshUtils_createMesh_static__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MeshUtils_createMesh_static) + +static bool js_cc_MeshUtils_createDynamicMesh_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + index_t arg1 ; + cc::IDynamicGeometry *arg2 = 0 ; + cc::Mesh *arg3 = (cc::Mesh *) NULL ; + ccstd::optional< cc::ICreateDynamicMeshOptions > *arg4 = 0 ; + cc::IDynamicGeometry temp2 ; + ccstd::optional< cc::ICreateDynamicMeshOptions > temp4 ; + cc::Mesh *result = 0 ; + + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::Mesh *)cc::MeshUtils::createDynamicMesh(SWIG_STD_MOVE(arg1),(cc::IDynamicGeometry const &)*arg2,arg3,(ccstd::optional< cc::ICreateDynamicMeshOptions > 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_MeshUtils_createDynamicMesh_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + index_t arg1 ; + cc::IDynamicGeometry *arg2 = 0 ; + cc::Mesh *arg3 = (cc::Mesh *) NULL ; + cc::IDynamicGeometry temp2 ; + cc::Mesh *result = 0 ; + + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mesh *)cc::MeshUtils::createDynamicMesh(SWIG_STD_MOVE(arg1),(cc::IDynamicGeometry 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; +} + +static bool js_cc_MeshUtils_createDynamicMesh_static__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + index_t arg1 ; + cc::IDynamicGeometry *arg2 = 0 ; + cc::IDynamicGeometry temp2 ; + cc::Mesh *result = 0 ; + + + 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::Mesh *)cc::MeshUtils::createDynamicMesh(SWIG_STD_MOVE(arg1),(cc::IDynamicGeometry 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; +} + +static bool js_cc_MeshUtils_createDynamicMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_MeshUtils_createDynamicMesh_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_MeshUtils_createDynamicMesh_static__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MeshUtils_createDynamicMesh_static__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MeshUtils_createDynamicMesh_static) + +static bool js_cc_MeshUtils_inflateMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = 0 ; + cc::Uint8Array *arg2 = 0 ; + cc::Mesh::IStruct temp1 ; + cc::Uint8Array temp2 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::MeshUtils::inflateMesh((cc::Mesh::IStruct const &)*arg1,*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MeshUtils_inflateMesh_static) + +static bool js_cc_MeshUtils_decodeMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = 0 ; + cc::Uint8Array *arg2 = 0 ; + cc::Mesh::IStruct temp1 ; + cc::Uint8Array temp2 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::MeshUtils::decodeMesh(*arg1,*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MeshUtils_decodeMesh_static) + +static bool js_cc_MeshUtils_dequantizeMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = 0 ; + cc::Uint8Array *arg2 = 0 ; + cc::Mesh::IStruct temp1 ; + cc::Uint8Array temp2 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::MeshUtils::dequantizeMesh(*arg1,*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MeshUtils_dequantizeMesh_static) + +static bool js_new_cc_MeshUtils(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MeshUtils *result; + result = (cc::MeshUtils *)new cc::MeshUtils(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MeshUtils, __jsb_cc_MeshUtils_class, js_delete_cc_MeshUtils) + +static bool js_delete_cc_MeshUtils(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MeshUtils) + +bool js_register_cc_MeshUtils(se::Object* obj) { + auto* cls = se::Class::create("MeshUtils", obj, nullptr, _SE(js_new_cc_MeshUtils)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("createMesh", _SE(js_cc_MeshUtils_createMesh_static)); + cls->defineStaticFunction("createDynamicMesh", _SE(js_cc_MeshUtils_createDynamicMesh_static)); + cls->defineStaticFunction("inflateMesh", _SE(js_cc_MeshUtils_inflateMesh_static)); + cls->defineStaticFunction("decodeMesh", _SE(js_cc_MeshUtils_decodeMesh_static)); + cls->defineStaticFunction("dequantizeMesh", _SE(js_cc_MeshUtils_dequantizeMesh_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MeshUtils)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MeshUtils_proto = cls->getProto(); + __jsb_cc_MeshUtils_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_assets(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_Error(ns); + js_register_cc_BoundingBox(ns); + js_register_cc_VertexIdChannel(ns); + js_register_cc_NativeDep(ns); + js_register_cc_IGeometryOptions(ns); + js_register_cc_CustomAttribute(ns); + js_register_cc_IGeometry(ns); + js_register_cc_DynamicCustomAttribute(ns); + js_register_cc_IDynamicGeometry(ns); + js_register_cc_Asset(ns); + js_register_cc_TextureBase(ns); + js_register_cc_SimpleTexture(ns); + js_register_cc_ITexture2DSerializeData(ns); + js_register_cc_ITexture2DCreateInfo(ns); + js_register_cc_Texture2D(ns); + js_register_cc_ITextureCubeMipmap(ns); + js_register_cc_ITextureCubeSerializeMipmapData(ns); + js_register_cc_MipmapAtlasLayoutInfo(ns); + js_register_cc_TextureCubeMipmapAtlasInfo(ns); + js_register_cc_TextureCubeSerializeData(ns); + js_register_cc_TextureCube(ns); + js_register_cc_IRenderTextureCreateInfo(ns); + js_register_cc_RenderTexture(ns); + js_register_cc_BufferAsset(ns); + js_register_cc_IPropertyInfo(ns); + js_register_cc_RasterizerStateInfo(ns); + js_register_cc_DepthStencilStateInfo(ns); + js_register_cc_BlendTargetInfo(ns); + js_register_cc_BlendStateInfo(ns); + js_register_cc_IPassStates(ns); + js_register_cc_IPassInfoFull(ns); + js_register_cc_ITechniqueInfo(ns); + js_register_cc_IBlockInfo(ns); + js_register_cc_ISamplerTextureInfo(ns); + js_register_cc_ITextureInfo(ns); + js_register_cc_ISamplerInfo(ns); + js_register_cc_IBufferInfo(ns); + js_register_cc_IImageInfo(ns); + js_register_cc_IInputAttachmentInfo(ns); + js_register_cc_IAttributeInfo(ns); + js_register_cc_IDefineInfo(ns); + js_register_cc_IBuiltin(ns); + js_register_cc_IBuiltinInfo(ns); + js_register_cc_IBuiltins(ns); + js_register_cc_IDescriptorInfo(ns); + js_register_cc_IShaderSource(ns); + js_register_cc_IShaderInfo(ns); + js_register_cc_EffectAsset(ns); + js_register_cc_IMemoryImageSource(ns); + js_register_cc_ImageAsset(ns); + js_register_cc_SceneAsset(ns); + js_register_cc_TextAsset(ns); + js_register_cc_IMaterialInfo(ns); + js_register_cc_Material(ns); + js_register_cc_IGeometricInfo(ns); + js_register_cc_IFlatBuffer(ns); + js_register_cc_RenderingSubMesh(ns); + js_register_cc_BuiltinResMgr(ns); + js_register_cc_IMeshBufferView(ns); + js_register_cc_MorphTarget(ns); + js_register_cc_SubMeshMorph(ns); + js_register_cc_Morph(ns); + js_register_cc_MorphRenderingInstance(ns); + js_register_cc_MorphRendering(ns); + js_register_cc_StdMorphRendering(ns); + js_register_cc_Mesh(ns); + js_register_cc_Mesh_IVertexBundle(ns); + js_register_cc_Mesh_IMeshCluster(ns); + js_register_cc_Mesh_ISubMesh(ns); + js_register_cc_Mesh_IDynamicInfo(ns); + js_register_cc_Mesh_IDynamicStruct(ns); + js_register_cc_Mesh_IStruct(ns); + js_register_cc_Mesh_ICreateInfo(ns); + js_register_cc_Skeleton(ns); + js_register_cc_ICreateMeshOptions(ns); + js_register_cc_ICreateDynamicMeshOptions(ns); + js_register_cc_MeshUtils(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_assets_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_assets_auto.h new file mode 100644 index 0000000000..b3e745c3e2 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_assets_auto.h @@ -0,0 +1,666 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "core/assets/Asset.h" +#include "core/assets/BufferAsset.h" +#include "core/assets/EffectAsset.h" +#include "core/assets/ImageAsset.h" +#include "core/assets/Material.h" +#include "core/builtin/BuiltinResMgr.h" +#include "3d/assets/Morph.h" +#include "3d/assets/Mesh.h" +#include "3d/assets/Skeleton.h" +#include "3d/misc/CreateMesh.h" + + + +bool register_all_assets(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::Error); +extern se::Object *__jsb_cc_Error_proto; // NOLINT +extern se::Class * __jsb_cc_Error_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Error * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::BoundingBox); +extern se::Object *__jsb_cc_BoundingBox_proto; // NOLINT +extern se::Class * __jsb_cc_BoundingBox_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::BoundingBox * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::VertexIdChannel); +extern se::Object *__jsb_cc_VertexIdChannel_proto; // NOLINT +extern se::Class * __jsb_cc_VertexIdChannel_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::VertexIdChannel * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::NativeDep); +extern se::Object *__jsb_cc_NativeDep_proto; // NOLINT +extern se::Class * __jsb_cc_NativeDep_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::NativeDep * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IGeometryOptions); +extern se::Object *__jsb_cc_IGeometryOptions_proto; // NOLINT +extern se::Class * __jsb_cc_IGeometryOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometryOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::CustomAttribute); +extern se::Object *__jsb_cc_CustomAttribute_proto; // NOLINT +extern se::Class * __jsb_cc_CustomAttribute_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::CustomAttribute * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IGeometry); +extern se::Object *__jsb_cc_IGeometry_proto; // NOLINT +extern se::Class * __jsb_cc_IGeometry_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometry * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::DynamicCustomAttribute); +extern se::Object *__jsb_cc_DynamicCustomAttribute_proto; // NOLINT +extern se::Class * __jsb_cc_DynamicCustomAttribute_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::DynamicCustomAttribute * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IDynamicGeometry); +extern se::Object *__jsb_cc_IDynamicGeometry_proto; // NOLINT +extern se::Class * __jsb_cc_IDynamicGeometry_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDynamicGeometry * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Asset); +extern se::Object *__jsb_cc_Asset_proto; // NOLINT +extern se::Class * __jsb_cc_Asset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureBase); +extern se::Object *__jsb_cc_TextureBase_proto; // NOLINT +extern se::Class * __jsb_cc_TextureBase_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SimpleTexture); +extern se::Object *__jsb_cc_SimpleTexture_proto; // NOLINT +extern se::Class * __jsb_cc_SimpleTexture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ITexture2DSerializeData); +extern se::Object *__jsb_cc_ITexture2DSerializeData_proto; // NOLINT +extern se::Class * __jsb_cc_ITexture2DSerializeData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DSerializeData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITexture2DCreateInfo); +extern se::Object *__jsb_cc_ITexture2DCreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ITexture2DCreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DCreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Texture2D); +extern se::Object *__jsb_cc_Texture2D_proto; // NOLINT +extern se::Class * __jsb_cc_Texture2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ITextureCubeMipmap); +extern se::Object *__jsb_cc_ITextureCubeMipmap_proto; // NOLINT +extern se::Class * __jsb_cc_ITextureCubeMipmap_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeMipmap * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITextureCubeSerializeMipmapData); +extern se::Object *__jsb_cc_ITextureCubeSerializeMipmapData_proto; // NOLINT +extern se::Class * __jsb_cc_ITextureCubeSerializeMipmapData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeSerializeMipmapData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MipmapAtlasLayoutInfo); +extern se::Object *__jsb_cc_MipmapAtlasLayoutInfo_proto; // NOLINT +extern se::Class * __jsb_cc_MipmapAtlasLayoutInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::MipmapAtlasLayoutInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureCubeMipmapAtlasInfo); +extern se::Object *__jsb_cc_TextureCubeMipmapAtlasInfo_proto; // NOLINT +extern se::Class * __jsb_cc_TextureCubeMipmapAtlasInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeMipmapAtlasInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureCubeSerializeData); +extern se::Object *__jsb_cc_TextureCubeSerializeData_proto; // NOLINT +extern se::Class * __jsb_cc_TextureCubeSerializeData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeSerializeData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureCube); +extern se::Object *__jsb_cc_TextureCube_proto; // NOLINT +extern se::Class * __jsb_cc_TextureCube_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IRenderTextureCreateInfo); +extern se::Object *__jsb_cc_IRenderTextureCreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IRenderTextureCreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IRenderTextureCreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderTexture); +extern se::Object *__jsb_cc_RenderTexture_proto; // NOLINT +extern se::Class * __jsb_cc_RenderTexture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::BufferAsset); +extern se::Object *__jsb_cc_BufferAsset_proto; // NOLINT +extern se::Class * __jsb_cc_BufferAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IPropertyInfo); +extern se::Object *__jsb_cc_IPropertyInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IPropertyInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPropertyInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RasterizerStateInfo); +extern se::Object *__jsb_cc_RasterizerStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_RasterizerStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::RasterizerStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::DepthStencilStateInfo); +extern se::Object *__jsb_cc_DepthStencilStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_DepthStencilStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::DepthStencilStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::BlendTargetInfo); +extern se::Object *__jsb_cc_BlendTargetInfo_proto; // NOLINT +extern se::Class * __jsb_cc_BlendTargetInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendTargetInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::BlendStateInfo); +extern se::Object *__jsb_cc_BlendStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_BlendStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IPassStates); +extern se::Object *__jsb_cc_IPassStates_proto; // NOLINT +extern se::Class * __jsb_cc_IPassStates_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassStates * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IPassInfoFull); +extern se::Object *__jsb_cc_IPassInfoFull_proto; // NOLINT +extern se::Class * __jsb_cc_IPassInfoFull_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassInfoFull * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITechniqueInfo); +extern se::Object *__jsb_cc_ITechniqueInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ITechniqueInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITechniqueInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBlockInfo); +extern se::Object *__jsb_cc_IBlockInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IBlockInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBlockInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ISamplerTextureInfo); +extern se::Object *__jsb_cc_ISamplerTextureInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ISamplerTextureInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerTextureInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITextureInfo); +extern se::Object *__jsb_cc_ITextureInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ITextureInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ISamplerInfo); +extern se::Object *__jsb_cc_ISamplerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ISamplerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBufferInfo); +extern se::Object *__jsb_cc_IBufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IBufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IImageInfo); +extern se::Object *__jsb_cc_IImageInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IImageInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IImageInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IInputAttachmentInfo); +extern se::Object *__jsb_cc_IInputAttachmentInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IInputAttachmentInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IInputAttachmentInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IAttributeInfo); +extern se::Object *__jsb_cc_IAttributeInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IAttributeInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IAttributeInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IDefineInfo); +extern se::Object *__jsb_cc_IDefineInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IDefineInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBuiltin); +extern se::Object *__jsb_cc_IBuiltin_proto; // NOLINT +extern se::Class * __jsb_cc_IBuiltin_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltin * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBuiltinInfo); +extern se::Object *__jsb_cc_IBuiltinInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IBuiltinInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltinInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBuiltins); +extern se::Object *__jsb_cc_IBuiltins_proto; // NOLINT +extern se::Class * __jsb_cc_IBuiltins_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltins * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IDescriptorInfo); +extern se::Object *__jsb_cc_IDescriptorInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IDescriptorInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDescriptorInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IShaderSource); +extern se::Object *__jsb_cc_IShaderSource_proto; // NOLINT +extern se::Class * __jsb_cc_IShaderSource_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderSource * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IShaderInfo); +extern se::Object *__jsb_cc_IShaderInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IShaderInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::EffectAsset); +extern se::Object *__jsb_cc_EffectAsset_proto; // NOLINT +extern se::Class * __jsb_cc_EffectAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMemoryImageSource); +extern se::Object *__jsb_cc_IMemoryImageSource_proto; // NOLINT +extern se::Class * __jsb_cc_IMemoryImageSource_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMemoryImageSource * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ImageAsset); +extern se::Object *__jsb_cc_ImageAsset_proto; // NOLINT +extern se::Class * __jsb_cc_ImageAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SceneAsset); +extern se::Object *__jsb_cc_SceneAsset_proto; // NOLINT +extern se::Class * __jsb_cc_SceneAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::TextAsset); +extern se::Object *__jsb_cc_TextAsset_proto; // NOLINT +extern se::Class * __jsb_cc_TextAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMaterialInfo); +extern se::Object *__jsb_cc_IMaterialInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IMaterialInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Material); +extern se::Object *__jsb_cc_Material_proto; // NOLINT +extern se::Class * __jsb_cc_Material_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IGeometricInfo); +extern se::Object *__jsb_cc_IGeometricInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IGeometricInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometricInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IFlatBuffer); +extern se::Object *__jsb_cc_IFlatBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_IFlatBuffer_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IFlatBuffer * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderingSubMesh); +extern se::Object *__jsb_cc_RenderingSubMesh_proto; // NOLINT +extern se::Class * __jsb_cc_RenderingSubMesh_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::BuiltinResMgr); +extern se::Object *__jsb_cc_BuiltinResMgr_proto; // NOLINT +extern se::Class * __jsb_cc_BuiltinResMgr_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMeshBufferView); +extern se::Object *__jsb_cc_IMeshBufferView_proto; // NOLINT +extern se::Class * __jsb_cc_IMeshBufferView_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMeshBufferView * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphTarget); +extern se::Object *__jsb_cc_MorphTarget_proto; // NOLINT +extern se::Class * __jsb_cc_MorphTarget_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::MorphTarget * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::SubMeshMorph); +extern se::Object *__jsb_cc_SubMeshMorph_proto; // NOLINT +extern se::Class * __jsb_cc_SubMeshMorph_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::SubMeshMorph * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Morph); +extern se::Object *__jsb_cc_Morph_proto; // NOLINT +extern se::Class * __jsb_cc_Morph_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Morph * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphRenderingInstance); +extern se::Object *__jsb_cc_MorphRenderingInstance_proto; // NOLINT +extern se::Class * __jsb_cc_MorphRenderingInstance_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphRendering); +extern se::Object *__jsb_cc_MorphRendering_proto; // NOLINT +extern se::Class * __jsb_cc_MorphRendering_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::StdMorphRendering); +extern se::Object *__jsb_cc_StdMorphRendering_proto; // NOLINT +extern se::Class * __jsb_cc_StdMorphRendering_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IVertexBundle); +extern se::Object *__jsb_cc_Mesh_IVertexBundle_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IVertexBundle_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IVertexBundle * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IMeshCluster); +extern se::Object *__jsb_cc_Mesh_IMeshCluster_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IMeshCluster_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IMeshCluster * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::ISubMesh); +extern se::Object *__jsb_cc_Mesh_ISubMesh_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_ISubMesh_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ISubMesh * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IDynamicInfo); +extern se::Object *__jsb_cc_Mesh_IDynamicInfo_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IDynamicInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IDynamicStruct); +extern se::Object *__jsb_cc_Mesh_IDynamicStruct_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IDynamicStruct_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicStruct * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IStruct); +extern se::Object *__jsb_cc_Mesh_IStruct_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IStruct_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IStruct * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::ICreateInfo); +extern se::Object *__jsb_cc_Mesh_ICreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_ICreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ICreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh); +extern se::Object *__jsb_cc_Mesh_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Skeleton); +extern se::Object *__jsb_cc_Skeleton_proto; // NOLINT +extern se::Class * __jsb_cc_Skeleton_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ICreateMeshOptions); +extern se::Object *__jsb_cc_ICreateMeshOptions_proto; // NOLINT +extern se::Class * __jsb_cc_ICreateMeshOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateMeshOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ICreateDynamicMeshOptions); +extern se::Object *__jsb_cc_ICreateDynamicMeshOptions_proto; // NOLINT +extern se::Class * __jsb_cc_ICreateDynamicMeshOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateDynamicMeshOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MeshUtils); +extern se::Object *__jsb_cc_MeshUtils_proto; // NOLINT +extern se::Class * __jsb_cc_MeshUtils_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_audio_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_audio_auto.cpp new file mode 100644 index 0000000000..14498c5ef2 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_audio_auto.cpp @@ -0,0 +1,1200 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_audio_auto.h" + + + +se::Class* __jsb_cc_AudioProfile_class = nullptr; +se::Object* __jsb_cc_AudioProfile_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_AudioProfile) + +static bool js_cc_AudioProfile_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_AudioProfile_name_set) + +static bool js_cc_AudioProfile_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_AudioProfile_name_get) + +static bool js_cc_AudioProfile_maxInstances_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxInstances, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_AudioProfile_maxInstances_set) + +static bool js_cc_AudioProfile_maxInstances_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxInstances, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_AudioProfile_maxInstances_get) + +static bool js_cc_AudioProfile_minDelay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minDelay, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_AudioProfile_minDelay_set) + +static bool js_cc_AudioProfile_minDelay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minDelay, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_AudioProfile_minDelay_get) + +static bool js_new_cc_AudioProfile(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::AudioProfile *result; + result = (cc::AudioProfile *)new cc::AudioProfile(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_AudioProfile, __jsb_cc_AudioProfile_class, js_delete_cc_AudioProfile) + +static bool js_delete_cc_AudioProfile(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_AudioProfile) + +bool js_register_cc_AudioProfile(se::Object* obj) { + auto* cls = se::Class::create("AudioProfile", obj, nullptr, _SE(js_new_cc_AudioProfile)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_AudioProfile_name_get), _SE(js_cc_AudioProfile_name_set)); + cls->defineProperty("maxInstances", _SE(js_cc_AudioProfile_maxInstances_get), _SE(js_cc_AudioProfile_maxInstances_set)); + cls->defineProperty("minDelay", _SE(js_cc_AudioProfile_minDelay_get), _SE(js_cc_AudioProfile_minDelay_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_AudioProfile)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_AudioProfile_proto = cls->getProto(); + __jsb_cc_AudioProfile_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_AudioEngine_class = nullptr; +se::Object* __jsb_cc_AudioEngine_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_AudioEngine) + +static bool js_cc_AudioEngine_lazyInit_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)cc::AudioEngine::lazyInit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_lazyInit_static) + +static bool js_cc_AudioEngine_end_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::end(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_end_static) + +static bool js_cc_AudioEngine_getDefaultProfile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::AudioProfile *)cc::AudioEngine::getDefaultProfile(); + + 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_AudioEngine_getDefaultProfile_static) + +static bool js_cc_AudioEngine_play2d_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + bool arg2 ; + float arg3 ; + cc::AudioProfile *arg4 = (cc::AudioProfile *) NULL ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1,arg2,arg3,(cc::AudioProfile const *)arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + bool arg2 ; + float arg3 ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + bool arg2 ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_AudioEngine_play2d_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_AudioEngine_play2d_static__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_AudioEngine_play2d_static__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_AudioEngine_play2d_static__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_AudioEngine_play2d_static) + +static bool js_cc_AudioEngine_setLoop_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + bool arg2 ; + + 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], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::AudioEngine::setLoop(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setLoop_static) + +static bool js_cc_AudioEngine_isLoop_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::AudioEngine::isLoop(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_isLoop_static) + +static bool js_cc_AudioEngine_setVolume_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float arg2 ; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::AudioEngine::setVolume(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setVolume_static) + +static bool js_cc_AudioEngine_setVolumeFactor_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::AudioEngine::setVolumeFactor(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setVolumeFactor_static) + +static bool js_cc_AudioEngine_getVolume_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::AudioEngine::getVolume(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getVolume_static) + +static bool js_cc_AudioEngine_pause_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + + 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::AudioEngine::pause(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_pause_static) + +static bool js_cc_AudioEngine_pauseAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::pauseAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_pauseAll_static) + +static bool js_cc_AudioEngine_resume_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + + 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::AudioEngine::resume(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_resume_static) + +static bool js_cc_AudioEngine_resumeAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::resumeAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_resumeAll_static) + +static bool js_cc_AudioEngine_stop_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + + 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::AudioEngine::stop(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_stop_static) + +static bool js_cc_AudioEngine_stopAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::stopAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_stopAll_static) + +static bool js_cc_AudioEngine_setCurrentTime_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float arg2 ; + bool result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::AudioEngine::setCurrentTime(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setCurrentTime_static) + +static bool js_cc_AudioEngine_getCurrentTime_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::AudioEngine::getCurrentTime(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getCurrentTime_static) + +static bool js_cc_AudioEngine_getDuration_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::AudioEngine::getDuration(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getDuration_static) + +static bool js_cc_AudioEngine_getDurationFromFile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (float)cc::AudioEngine::getDurationFromFile((ccstd::string const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getDurationFromFile_static) + +static bool js_cc_AudioEngine_getState_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + cc::AudioEngine::AudioState result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::AudioEngine::AudioState)cc::AudioEngine::getState(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_FUNC(js_cc_AudioEngine_getState_static) + +static bool js_cc_AudioEngine_setFinishCallback_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + std::function< void (int,ccstd::string const &) > *arg2 = 0 ; + std::function< void (int,ccstd::string const &) > temp2 ; + + 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; + + cc::AudioEngine::setFinishCallback(arg1,(std::function< void (int,ccstd::string const &) > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setFinishCallback_static) + +static bool js_cc_AudioEngine_getMaxAudioInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (int)cc::AudioEngine::getMaxAudioInstance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getMaxAudioInstance_static) + +static bool js_cc_AudioEngine_setMaxAudioInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::AudioEngine::setMaxAudioInstance(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setMaxAudioInstance_static) + +static bool js_cc_AudioEngine_uncache_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + cc::AudioEngine::uncache((ccstd::string const &)*arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_uncache_static) + +static bool js_cc_AudioEngine_uncacheAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::uncacheAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_uncacheAll_static) + +static bool js_cc_AudioEngine_getProfile_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + int arg1 ; + cc::AudioProfile *result = 0 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::AudioProfile *)cc::AudioEngine::getProfile(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; +} + +static bool js_cc_AudioEngine_getProfile_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::AudioProfile *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::AudioProfile *)cc::AudioEngine::getProfile((ccstd::string const &)*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; +} + +static bool js_cc_AudioEngine_getProfile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_AudioEngine_getProfile_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_AudioEngine_getProfile_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_AudioEngine_getProfile_static) + +static bool js_cc_AudioEngine_preload_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + cc::AudioEngine::preload((ccstd::string const &)*arg1); + + + return true; +} + +static bool js_cc_AudioEngine_preload_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + std::function< void (bool) > *arg2 = 0 ; + ccstd::string temp1 ; + std::function< void (bool) > temp2 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::AudioEngine::preload((ccstd::string const &)*arg1,(std::function< void (bool) > const &)*arg2); + + + return true; +} + +static bool js_cc_AudioEngine_preload_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_AudioEngine_preload_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_AudioEngine_preload_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_AudioEngine_preload_static) + +static bool js_cc_AudioEngine_getPlayingAudioCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (int)cc::AudioEngine::getPlayingAudioCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getPlayingAudioCount_static) + +static bool js_cc_AudioEngine_setEnabled_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::AudioEngine::setEnabled(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setEnabled_static) + +static bool js_cc_AudioEngine_isEnabled_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)cc::AudioEngine::isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_isEnabled_static) + +static bool js_new_cc_AudioEngine(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::AudioEngine *result; + result = (cc::AudioEngine *)new cc::AudioEngine(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_AudioEngine, __jsb_cc_AudioEngine_class, js_delete_cc_AudioEngine) + +static bool js_delete_cc_AudioEngine(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_AudioEngine) + +bool js_register_cc_AudioEngine(se::Object* obj) { + auto* cls = se::Class::create("AudioEngine", obj, nullptr, _SE(js_new_cc_AudioEngine)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("lazyInit", _SE(js_cc_AudioEngine_lazyInit_static)); + cls->defineStaticFunction("end", _SE(js_cc_AudioEngine_end_static)); + cls->defineStaticFunction("getDefaultProfile", _SE(js_cc_AudioEngine_getDefaultProfile_static)); + cls->defineStaticFunction("play2d", _SE(js_cc_AudioEngine_play2d_static)); + cls->defineStaticFunction("setLoop", _SE(js_cc_AudioEngine_setLoop_static)); + cls->defineStaticFunction("isLoop", _SE(js_cc_AudioEngine_isLoop_static)); + cls->defineStaticFunction("setVolume", _SE(js_cc_AudioEngine_setVolume_static)); + cls->defineStaticFunction("setVolumeFactor", _SE(js_cc_AudioEngine_setVolumeFactor_static)); + cls->defineStaticFunction("getVolume", _SE(js_cc_AudioEngine_getVolume_static)); + cls->defineStaticFunction("pause", _SE(js_cc_AudioEngine_pause_static)); + cls->defineStaticFunction("pauseAll", _SE(js_cc_AudioEngine_pauseAll_static)); + cls->defineStaticFunction("resume", _SE(js_cc_AudioEngine_resume_static)); + cls->defineStaticFunction("resumeAll", _SE(js_cc_AudioEngine_resumeAll_static)); + cls->defineStaticFunction("stop", _SE(js_cc_AudioEngine_stop_static)); + cls->defineStaticFunction("stopAll", _SE(js_cc_AudioEngine_stopAll_static)); + cls->defineStaticFunction("setCurrentTime", _SE(js_cc_AudioEngine_setCurrentTime_static)); + cls->defineStaticFunction("getCurrentTime", _SE(js_cc_AudioEngine_getCurrentTime_static)); + cls->defineStaticFunction("getDuration", _SE(js_cc_AudioEngine_getDuration_static)); + cls->defineStaticFunction("getDurationFromFile", _SE(js_cc_AudioEngine_getDurationFromFile_static)); + cls->defineStaticFunction("getState", _SE(js_cc_AudioEngine_getState_static)); + cls->defineStaticFunction("setFinishCallback", _SE(js_cc_AudioEngine_setFinishCallback_static)); + cls->defineStaticFunction("getMaxAudioInstance", _SE(js_cc_AudioEngine_getMaxAudioInstance_static)); + cls->defineStaticFunction("setMaxAudioInstance", _SE(js_cc_AudioEngine_setMaxAudioInstance_static)); + cls->defineStaticFunction("uncache", _SE(js_cc_AudioEngine_uncache_static)); + cls->defineStaticFunction("uncacheAll", _SE(js_cc_AudioEngine_uncacheAll_static)); + cls->defineStaticFunction("getProfile", _SE(js_cc_AudioEngine_getProfile_static)); + cls->defineStaticFunction("preload", _SE(js_cc_AudioEngine_preload_static)); + cls->defineStaticFunction("getPlayingAudioCount", _SE(js_cc_AudioEngine_getPlayingAudioCount_static)); + cls->defineStaticFunction("setEnabled", _SE(js_cc_AudioEngine_setEnabled_static)); + cls->defineStaticFunction("isEnabled", _SE(js_cc_AudioEngine_isEnabled_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_AudioEngine)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_AudioEngine_proto = cls->getProto(); + __jsb_cc_AudioEngine_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_audio(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_AudioProfile(ns); + js_register_cc_AudioEngine(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_audio_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_audio_auto.h new file mode 100644 index 0000000000..d68b2ac375 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_audio_auto.h @@ -0,0 +1,54 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "audio/include/AudioEngine.h" + + + +bool register_all_audio(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::AudioProfile); +extern se::Object *__jsb_cc_AudioProfile_proto; // NOLINT +extern se::Class * __jsb_cc_AudioProfile_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::AudioEngine); +extern se::Object *__jsb_cc_AudioEngine_proto; // NOLINT +extern se::Class * __jsb_cc_AudioEngine_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_box2d_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_box2d_auto.cpp new file mode 100644 index 0000000000..9c6acf4496 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_box2d_auto.cpp @@ -0,0 +1,24966 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_box2d_auto.h" + +#define SWIGINTERN static + + + +static bool js_b2IsValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)b2IsValid(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2IsValid) + +se::Class* __jsb_b2Vec2_class = nullptr; +se::Object* __jsb_b2Vec2_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Vec2) + +static bool js_new_b2Vec2__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec2 *result; + result = (b2Vec2 *)new b2Vec2(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec2__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + b2Vec2 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Vec2 *)new b2Vec2(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec2(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Vec2__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_b2Vec2__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec2"); + return false; +} +SE_BIND_CTOR(js_new_b2Vec2, __jsb_b2Vec2_class, js_delete_b2Vec2) + +static bool js_Vec2_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Vec2_SetZero) + +static bool js_Vec2_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Vec2_Set) + +static bool js_Vec2_Length(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Vec2 const *)arg1)->Length(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_Length) + +static bool js_Vec2_LengthSquared(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Vec2 const *)arg1)->LengthSquared(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_LengthSquared) + +static bool js_Vec2_Normalize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->Normalize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_Normalize) + +static bool js_Vec2_IsValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Vec2 const *)arg1)->IsValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_IsValid) + +static bool js_Vec2_Skew(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Vec2 const *)arg1)->Skew(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Vec2_Skew) + +static bool js_Vec2_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec2_x_set) + +static bool js_Vec2_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec2_x_get) + +static bool js_Vec2_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec2_y_set) + +static bool js_Vec2_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec2_y_get) + +static bool js_delete_b2Vec2(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Vec2) + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec2 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + return ok; +} + + +bool js_register_b2Vec2(se::Object* obj) { + auto* cls = se::Class::create("Vec2", obj, nullptr, _SE(js_new_b2Vec2)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_Vec2_x_get), _SE(js_Vec2_x_set)); + cls->defineProperty("y", _SE(js_Vec2_y_get), _SE(js_Vec2_y_set)); + + cls->defineFunction("SetZero", _SE(js_Vec2_SetZero)); + cls->defineFunction("Set", _SE(js_Vec2_Set)); + cls->defineFunction("Length", _SE(js_Vec2_Length)); + cls->defineFunction("LengthSquared", _SE(js_Vec2_LengthSquared)); + cls->defineFunction("Normalize", _SE(js_Vec2_Normalize)); + cls->defineFunction("IsValid", _SE(js_Vec2_IsValid)); + cls->defineFunction("Skew", _SE(js_Vec2_Skew)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Vec2)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Vec2_proto = cls->getProto(); + __jsb_b2Vec2_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Vec3_class = nullptr; +se::Object* __jsb_b2Vec3_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Vec3) + +static bool js_new_b2Vec3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec3 *result; + result = (b2Vec3 *)new b2Vec3(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + b2Vec3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Vec3 *)new b2Vec3(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec3(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Vec3__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_b2Vec3__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec3"); + return false; +} +SE_BIND_CTOR(js_new_b2Vec3, __jsb_b2Vec3_class, js_delete_b2Vec3) + +static bool js_Vec3_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Vec3_SetZero) + +static bool js_Vec3_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Vec3_Set) + +static bool js_Vec3_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec3_x_set) + +static bool js_Vec3_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec3_x_get) + +static bool js_Vec3_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec3_y_set) + +static bool js_Vec3_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec3_y_get) + +static bool js_Vec3_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec3_z_set) + +static bool js_Vec3_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec3_z_get) + +static bool js_delete_b2Vec3(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Vec3) + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec3 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + return ok; +} + + +bool js_register_b2Vec3(se::Object* obj) { + auto* cls = se::Class::create("Vec3", obj, nullptr, _SE(js_new_b2Vec3)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_Vec3_x_get), _SE(js_Vec3_x_set)); + cls->defineProperty("y", _SE(js_Vec3_y_get), _SE(js_Vec3_y_set)); + cls->defineProperty("z", _SE(js_Vec3_z_get), _SE(js_Vec3_z_set)); + + cls->defineFunction("SetZero", _SE(js_Vec3_SetZero)); + cls->defineFunction("Set", _SE(js_Vec3_Set)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Vec3)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Vec3_proto = cls->getProto(); + __jsb_b2Vec3_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Mat22_class = nullptr; +se::Object* __jsb_b2Mat22_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Mat22) + +static bool js_new_b2Mat22__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Mat22 *result; + result = (b2Mat22 *)new b2Mat22(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat22__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Mat22 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (b2Mat22 *)new b2Mat22((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat22__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + b2Mat22 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Mat22 *)new b2Mat22(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat22(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Mat22__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_b2Mat22__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_b2Mat22__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat22"); + return false; +} +SE_BIND_CTOR(js_new_b2Mat22, __jsb_b2Mat22_class, js_delete_b2Mat22) + +static bool js_Mat22_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_Mat22_Set) + +static bool js_Mat22_SetIdentity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetIdentity(); + + + return true; +} +SE_BIND_FUNC(js_Mat22_SetIdentity) + +static bool js_Mat22_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Mat22_SetZero) + +static bool js_Mat22_GetInverse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + b2Mat22 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Mat22 const *)arg1)->GetInverse(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat22_GetInverse) + +static bool js_Mat22_Solve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Mat22 const *)arg1)->Solve((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat22_Solve) + +static bool js_Mat22_ex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat22_ex_set) + +static bool js_Mat22_ex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat22_ex_get) + +static bool js_Mat22_ey_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ey, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat22_ey_set) + +static bool js_Mat22_ey_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ey, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ey, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat22_ey_get) + +static bool js_delete_b2Mat22(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Mat22) + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat22 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("ex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ex), ctx); + } + + + json->getProperty("ey", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ey), ctx); + } + + + return ok; +} + + +bool js_register_b2Mat22(se::Object* obj) { + auto* cls = se::Class::create("Mat22", obj, nullptr, _SE(js_new_b2Mat22)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("ex", _SE(js_Mat22_ex_get), _SE(js_Mat22_ex_set)); + cls->defineProperty("ey", _SE(js_Mat22_ey_get), _SE(js_Mat22_ey_set)); + + cls->defineFunction("Set", _SE(js_Mat22_Set)); + cls->defineFunction("SetIdentity", _SE(js_Mat22_SetIdentity)); + cls->defineFunction("SetZero", _SE(js_Mat22_SetZero)); + cls->defineFunction("GetInverse", _SE(js_Mat22_GetInverse)); + cls->defineFunction("Solve", _SE(js_Mat22_Solve)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Mat22)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Mat22_proto = cls->getProto(); + __jsb_b2Mat22_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Mat33_class = nullptr; +se::Object* __jsb_b2Mat33_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Mat33) + +static bool js_new_b2Mat33__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Mat33 *result; + result = (b2Mat33 *)new b2Mat33(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat33__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Vec3 *arg3 = 0 ; + b2Vec3 temp1 ; + b2Vec3 temp2 ; + b2Vec3 temp3 ; + b2Mat33 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (b2Mat33 *)new b2Mat33((b2Vec3 const &)*arg1,(b2Vec3 const &)*arg2,(b2Vec3 const &)*arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat33(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Mat33__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_b2Mat33__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat33"); + return false; +} +SE_BIND_CTOR(js_new_b2Mat33, __jsb_b2Mat33_class, js_delete_b2Mat33) + +static bool js_Mat33_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Mat33_SetZero) + +static bool js_Mat33_Solve33(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Vec3 *arg2 = 0 ; + b2Vec3 temp2 ; + b2Vec3 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Mat33 const *)arg1)->Solve33((b2Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat33_Solve33) + +static bool js_Mat33_Solve22(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Mat33 const *)arg1)->Solve22((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat33_Solve22) + +static bool js_Mat33_GetInverse22(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Mat33 *arg2 = (b2Mat33 *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Mat33 const *)arg1)->GetInverse22(arg2); + + + return true; +} +SE_BIND_FUNC(js_Mat33_GetInverse22) + +static bool js_Mat33_GetSymInverse33(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Mat33 *arg2 = (b2Mat33 *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Mat33 const *)arg1)->GetSymInverse33(arg2); + + + return true; +} +SE_BIND_FUNC(js_Mat33_GetSymInverse33) + +static bool js_Mat33_ex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat33_ex_set) + +static bool js_Mat33_ex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat33_ex_get) + +static bool js_Mat33_ey_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ey, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat33_ey_set) + +static bool js_Mat33_ey_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ey, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ey, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat33_ey_get) + +static bool js_Mat33_ez_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ez, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat33_ez_set) + +static bool js_Mat33_ez_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ez, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ez, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat33_ez_get) + +static bool js_delete_b2Mat33(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Mat33) + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat33 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("ex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ex), ctx); + } + + + json->getProperty("ey", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ey), ctx); + } + + + json->getProperty("ez", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ez), ctx); + } + + + return ok; +} + + +bool js_register_b2Mat33(se::Object* obj) { + auto* cls = se::Class::create("Mat33", obj, nullptr, _SE(js_new_b2Mat33)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("ex", _SE(js_Mat33_ex_get), _SE(js_Mat33_ex_set)); + cls->defineProperty("ey", _SE(js_Mat33_ey_get), _SE(js_Mat33_ey_set)); + cls->defineProperty("ez", _SE(js_Mat33_ez_get), _SE(js_Mat33_ez_set)); + + cls->defineFunction("SetZero", _SE(js_Mat33_SetZero)); + cls->defineFunction("Solve33", _SE(js_Mat33_Solve33)); + cls->defineFunction("Solve22", _SE(js_Mat33_Solve22)); + cls->defineFunction("GetInverse22", _SE(js_Mat33_GetInverse22)); + cls->defineFunction("GetSymInverse33", _SE(js_Mat33_GetSymInverse33)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Mat33)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Mat33_proto = cls->getProto(); + __jsb_b2Mat33_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Rot_class = nullptr; +se::Object* __jsb_b2Rot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Rot) + +static bool js_new_b2Rot__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Rot *result; + result = (b2Rot *)new b2Rot(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Rot__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + b2Rot *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Rot *)new b2Rot(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Rot(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Rot__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_b2Rot__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Rot"); + return false; +} +SE_BIND_CTOR(js_new_b2Rot, __jsb_b2Rot_class, js_delete_b2Rot) + +static bool js_Rot_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Set(arg2); + + + return true; +} +SE_BIND_FUNC(js_Rot_Set) + +static bool js_Rot_SetIdentity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetIdentity(); + + + return true; +} +SE_BIND_FUNC(js_Rot_SetIdentity) + +static bool js_Rot_GetAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Rot const *)arg1)->GetAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Rot_GetAngle) + +static bool js_Rot_GetXAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Rot const *)arg1)->GetXAxis(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Rot_GetXAxis) + +static bool js_Rot_GetYAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Rot const *)arg1)->GetYAxis(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Rot_GetYAxis) + +static bool js_Rot_s_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->s, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Rot_s_set) + +static bool js_Rot_s_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->s, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Rot_s_get) + +static bool js_Rot_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Rot_c_set) + +static bool js_Rot_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Rot_c_get) + +static bool js_delete_b2Rot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Rot) + +template<> +bool sevalue_to_native(const se::Value &from, b2Rot * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("s", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->s), ctx); + } + + + json->getProperty("c", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c), ctx); + } + + + return ok; +} + + +bool js_register_b2Rot(se::Object* obj) { + auto* cls = se::Class::create("Rot", obj, nullptr, _SE(js_new_b2Rot)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("s", _SE(js_Rot_s_get), _SE(js_Rot_s_set)); + cls->defineProperty("c", _SE(js_Rot_c_get), _SE(js_Rot_c_set)); + + cls->defineFunction("Set", _SE(js_Rot_Set)); + cls->defineFunction("SetIdentity", _SE(js_Rot_SetIdentity)); + cls->defineFunction("GetAngle", _SE(js_Rot_GetAngle)); + cls->defineFunction("GetXAxis", _SE(js_Rot_GetXAxis)); + cls->defineFunction("GetYAxis", _SE(js_Rot_GetYAxis)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Rot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Rot_proto = cls->getProto(); + __jsb_b2Rot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Transform_class = nullptr; +se::Object* __jsb_b2Transform_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Transform) + +static bool js_new_b2Transform__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Transform *result; + result = (b2Transform *)new b2Transform(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Transform__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = 0 ; + b2Rot *arg2 = 0 ; + b2Vec2 temp1 ; + b2Rot temp2 ; + b2Transform *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (b2Transform *)new b2Transform((b2Vec2 const &)*arg1,(b2Rot const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Transform(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Transform__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_b2Transform__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Transform"); + return false; +} +SE_BIND_CTOR(js_new_b2Transform, __jsb_b2Transform_class, js_delete_b2Transform) + +static bool js_Transform_SetIdentity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetIdentity(); + + + return true; +} +SE_BIND_FUNC(js_Transform_SetIdentity) + +static bool js_Transform_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Transform_Set) + +static bool js_Transform_p_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->p, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Transform_p_set) + +static bool js_Transform_p_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->p, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->p, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Transform_p_get) + +static bool js_Transform_q_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->q, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Transform_q_set) + +static bool js_Transform_q_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->q, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->q, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Transform_q_get) + +static bool js_delete_b2Transform(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Transform) + +template<> +bool sevalue_to_native(const se::Value &from, b2Transform * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("p", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->p), ctx); + } + + + json->getProperty("q", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->q), ctx); + } + + + return ok; +} + + +bool js_register_b2Transform(se::Object* obj) { + auto* cls = se::Class::create("Transform", obj, nullptr, _SE(js_new_b2Transform)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("p", _SE(js_Transform_p_get), _SE(js_Transform_p_set)); + cls->defineProperty("q", _SE(js_Transform_q_get), _SE(js_Transform_q_set)); + + cls->defineFunction("SetIdentity", _SE(js_Transform_SetIdentity)); + cls->defineFunction("Set", _SE(js_Transform_Set)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Transform)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Transform_proto = cls->getProto(); + __jsb_b2Transform_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Sweep_class = nullptr; +se::Object* __jsb_b2Sweep_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Sweep) + +static bool js_Sweep_GetTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + b2Transform *arg2 = (b2Transform *) NULL ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + ((b2Sweep const *)arg1)->GetTransform(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Sweep_GetTransform) + +static bool js_Sweep_Advance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Advance(arg2); + + + return true; +} +SE_BIND_FUNC(js_Sweep_Advance) + +static bool js_Sweep_Normalize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Normalize(); + + + return true; +} +SE_BIND_FUNC(js_Sweep_Normalize) + +static bool js_Sweep_localCenter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localCenter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_localCenter_set) + +static bool js_Sweep_localCenter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localCenter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localCenter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_localCenter_get) + +static bool js_Sweep_c0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_c0_set) + +static bool js_Sweep_c0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c0, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c0, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_c0_get) + +static bool js_Sweep_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_c_set) + +static bool js_Sweep_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_c_get) + +static bool js_Sweep_a0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_a0_set) + +static bool js_Sweep_a0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a0, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_a0_get) + +static bool js_Sweep_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_a_set) + +static bool js_Sweep_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_a_get) + +static bool js_Sweep_alpha0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->alpha0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_alpha0_set) + +static bool js_Sweep_alpha0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->alpha0, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_alpha0_get) + +static bool js_new_b2Sweep(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Sweep *result; + result = (b2Sweep *)new b2Sweep(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Sweep, __jsb_b2Sweep_class, js_delete_b2Sweep) + +static bool js_delete_b2Sweep(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Sweep) + +template<> +bool sevalue_to_native(const se::Value &from, b2Sweep * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localCenter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localCenter), ctx); + } + + + json->getProperty("c0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c0), ctx); + } + + + json->getProperty("c", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c), ctx); + } + + + json->getProperty("a0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a0), ctx); + } + + + json->getProperty("a", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a), ctx); + } + + + json->getProperty("alpha0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->alpha0), ctx); + } + + + return ok; +} + + +bool js_register_b2Sweep(se::Object* obj) { + auto* cls = se::Class::create("Sweep", obj, nullptr, _SE(js_new_b2Sweep)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localCenter", _SE(js_Sweep_localCenter_get), _SE(js_Sweep_localCenter_set)); + cls->defineProperty("c0", _SE(js_Sweep_c0_get), _SE(js_Sweep_c0_set)); + cls->defineProperty("c", _SE(js_Sweep_c_get), _SE(js_Sweep_c_set)); + cls->defineProperty("a0", _SE(js_Sweep_a0_get), _SE(js_Sweep_a0_set)); + cls->defineProperty("a", _SE(js_Sweep_a_get), _SE(js_Sweep_a_set)); + cls->defineProperty("alpha0", _SE(js_Sweep_alpha0_get), _SE(js_Sweep_alpha0_set)); + + cls->defineFunction("GetTransform", _SE(js_Sweep_GetTransform)); + cls->defineFunction("Advance", _SE(js_Sweep_Advance)); + cls->defineFunction("Normalize", _SE(js_Sweep_Normalize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Sweep)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Sweep_proto = cls->getProto(); + __jsb_b2Sweep_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_b2Dot__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Dot((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2Cross__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Cross((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2Cross__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + float arg2 ; + b2Vec2 temp1 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = b2Cross((b2Vec2 const &)*arg1,arg2); + + 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; +} + +static bool js_b2Cross__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + float arg1 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + 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 = b2Cross(arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Mat22 const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Mat22 const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Distance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Distance((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2Distance) + +static bool js_b2DistanceSquared(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2DistanceSquared((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2DistanceSquared) + +static bool js_b2Dot__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec3 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Vec3 temp1 ; + b2Vec3 temp2 ; + float result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Dot((b2Vec3 const &)*arg1,(b2Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2Dot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2Dot__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Dot__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Dot) + +static bool js_b2Cross__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec3 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Vec3 temp1 ; + b2Vec3 temp2 ; + b2Vec3 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Cross((b2Vec3 const &)*arg1,(b2Vec3 const &)*arg2); + + 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; +} + +static bool js_b2Cross(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2Cross__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Cross__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Cross__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Cross__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Cross) + +static bool js_b2Mul__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Mat22 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Mat22 temp2 ; + b2Mat22 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Mat22 const &)*arg1,(b2Mat22 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Mat22 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Mat22 temp2 ; + b2Mat22 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Mat22 const &)*arg1,(b2Mat22 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat33 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Mat33 temp1 ; + b2Vec3 temp2 ; + b2Vec3 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Mat33 const &)*arg1,(b2Vec3 const &)*arg2); + + 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; +} + +static bool js_b2Mul22(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Mat33 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul22((b2Mat33 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Mul22) + +static bool js_b2Mul__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Rot *arg2 = 0 ; + b2Rot temp1 ; + b2Rot temp2 ; + b2Rot result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Rot const &)*arg1,(b2Rot const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Rot *arg2 = 0 ; + b2Rot temp1 ; + b2Rot temp2 ; + b2Rot result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Rot const &)*arg1,(b2Rot const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Rot temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Rot const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Rot temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Rot const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Transform temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Transform const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Transform temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Transform const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Transform *arg2 = 0 ; + b2Transform temp1 ; + b2Transform temp2 ; + b2Transform result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Transform const &)*arg1,(b2Transform const &)*arg2); + + 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; +} + +static bool js_b2Mul(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2Mul__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Mul) + +static bool js_b2MulT__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Transform *arg2 = 0 ; + b2Transform temp1 ; + b2Transform temp2 ; + b2Transform result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Transform const &)*arg1,(b2Transform const &)*arg2); + + 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; +} + +static bool js_b2MulT(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2MulT__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2MulT) + +static bool js_b2Abs__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + b2Vec2 temp1 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = b2Abs((b2Vec2 const &)*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; +} + +static bool js_b2Abs__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Mat22 temp1 ; + b2Mat22 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = b2Abs((b2Mat22 const &)*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; +} + +static bool js_b2Abs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_b2Abs__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_b2Abs__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Abs) + +static bool js_b2Min(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Min((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Min) + +static bool js_b2Max(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Max((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Max) + +static bool js_b2Clamp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + b2Vec2 result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = b2Clamp((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Clamp) + +static bool js_b2NextPowerOfTwo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32 arg1 ; + uint32 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = b2NextPowerOfTwo(SWIG_STD_MOVE(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_FUNC(js_b2NextPowerOfTwo) + +static bool js_b2IsPowerOfTwo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32 arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)b2IsPowerOfTwo(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2IsPowerOfTwo) + +se::Class* __jsb_b2MassData_class = nullptr; +se::Object* __jsb_b2MassData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MassData) + +static bool js_MassData_mass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MassData_mass_set) + +static bool js_MassData_mass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MassData_mass_get) + +static bool js_MassData_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_MassData_center_set) + +static bool js_MassData_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_MassData_center_get) + +static bool js_MassData_I_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->I, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MassData_I_set) + +static bool js_MassData_I_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->I, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MassData_I_get) + +static bool js_new_b2MassData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2MassData *result; + result = (b2MassData *)new b2MassData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2MassData, __jsb_b2MassData_class, js_delete_b2MassData) + +static bool js_delete_b2MassData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MassData) + +template<> +bool sevalue_to_native(const se::Value &from, b2MassData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("mass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mass), ctx); + } + + + json->getProperty("center", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->center), ctx); + } + + + json->getProperty("I", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->I), ctx); + } + + + return ok; +} + + +bool js_register_b2MassData(se::Object* obj) { + auto* cls = se::Class::create("MassData", obj, nullptr, _SE(js_new_b2MassData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mass", _SE(js_MassData_mass_get), _SE(js_MassData_mass_set)); + cls->defineProperty("center", _SE(js_MassData_center_get), _SE(js_MassData_center_set)); + cls->defineProperty("I", _SE(js_MassData_I_get), _SE(js_MassData_I_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MassData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MassData_proto = cls->getProto(); + __jsb_b2MassData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Shape_class = nullptr; +se::Object* __jsb_b2Shape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Shape) + +static bool js_delete_b2Shape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Shape) + +static bool js_Shape_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2Shape::Type result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape::Type)((b2Shape const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Shape_GetType) + +static bool js_Shape_GetChildCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Shape const *)arg1)->GetChildCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Shape_GetChildCount) + +static bool js_Shape_TestPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2Transform *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Transform temp2 ; + b2Vec2 temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)((b2Shape const *)arg1)->TestPoint((b2Transform const &)*arg2,(b2Vec2 const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Shape_TestPoint) + +static bool js_Shape_RayCast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2RayCastOutput *arg2 = (b2RayCastOutput *) NULL ; + b2RayCastInput *arg3 = 0 ; + b2Transform *arg4 = 0 ; + int32 arg5 ; + b2RayCastInput temp3 ; + b2Transform temp4 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((b2Shape const *)arg1)->RayCast(arg2,(b2RayCastInput const &)*arg3,(b2Transform const &)*arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Shape_RayCast) + +static bool js_Shape_ComputeAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2AABB *arg2 = (b2AABB *) NULL ; + b2Transform *arg3 = 0 ; + int32 arg4 ; + b2Transform temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ((b2Shape const *)arg1)->ComputeAABB(arg2,(b2Transform const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Shape_ComputeAABB) + +static bool js_Shape_ComputeMass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + ((b2Shape const *)arg1)->ComputeMass(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Shape_ComputeMass) + +static bool js_Shape_m_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Shape_m_type_set) + +static bool js_Shape_m_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Shape_m_type_get) + +static bool js_Shape_m_radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_radius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Shape_m_radius_set) + +static bool js_Shape_m_radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_radius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Shape_m_radius_get) + +bool js_register_b2Shape(se::Object* obj) { + auto* cls = se::Class::create("Shape", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_type", _SE(js_Shape_m_type_get), _SE(js_Shape_m_type_set)); + cls->defineProperty("m_radius", _SE(js_Shape_m_radius_get), _SE(js_Shape_m_radius_set)); + + cls->defineFunction("GetType", _SE(js_Shape_GetType)); + cls->defineFunction("GetChildCount", _SE(js_Shape_GetChildCount)); + cls->defineFunction("TestPoint", _SE(js_Shape_TestPoint)); + cls->defineFunction("RayCast", _SE(js_Shape_RayCast)); + cls->defineFunction("ComputeAABB", _SE(js_Shape_ComputeAABB)); + cls->defineFunction("ComputeMass", _SE(js_Shape_ComputeMass)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Shape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Shape_proto = cls->getProto(); + __jsb_b2Shape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Color_class = nullptr; +se::Object* __jsb_b2Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Color) + +static bool js_new_b2Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Color *result; + result = (b2Color *)new b2Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + b2Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Color *)new b2Color(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Color__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + b2Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Color *)new b2Color(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Color__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_b2Color__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_b2Color__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Color"); + return false; +} +SE_BIND_CTOR(js_new_b2Color, __jsb_b2Color_class, js_delete_b2Color) + +static bool js_Color_Set__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Color *arg1 = (b2Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_Color_Set__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Color *arg1 = (b2Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3,arg4); + + + return true; +} + +static bool js_Color_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_Color_Set__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_Color_Set__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Color_Set) + +static bool js_Color_r_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->r, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_r_set) + +static bool js_Color_r_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->r, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_r_get) + +static bool js_Color_g_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->g, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_g_set) + +static bool js_Color_g_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->g, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_g_get) + +static bool js_Color_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_b_set) + +static bool js_Color_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_b_get) + +static bool js_Color_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_a_set) + +static bool js_Color_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_a_get) + +static bool js_delete_b2Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Color) + +template<> +bool sevalue_to_native(const se::Value &from, b2Color * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("r", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->r), ctx); + } + + + json->getProperty("g", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->g), ctx); + } + + + json->getProperty("b", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->b), ctx); + } + + + json->getProperty("a", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a), ctx); + } + + + return ok; +} + + +bool js_register_b2Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_b2Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("r", _SE(js_Color_r_get), _SE(js_Color_r_set)); + cls->defineProperty("g", _SE(js_Color_g_get), _SE(js_Color_g_set)); + cls->defineProperty("b", _SE(js_Color_b_get), _SE(js_Color_b_set)); + cls->defineProperty("a", _SE(js_Color_a_get), _SE(js_Color_a_set)); + + cls->defineFunction("Set", _SE(js_Color_Set)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Color_proto = cls->getProto(); + __jsb_b2Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactFeature_class = nullptr; +se::Object* __jsb_b2ContactFeature_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactFeature) + +static bool js_ContactFeature_indexA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_indexA_set) + +static bool js_ContactFeature_indexA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_indexA_get) + +static bool js_ContactFeature_indexB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_indexB_set) + +static bool js_ContactFeature_indexB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_indexB_get) + +static bool js_ContactFeature_typeA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->typeA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_typeA_set) + +static bool js_ContactFeature_typeA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->typeA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->typeA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_typeA_get) + +static bool js_ContactFeature_typeB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->typeB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_typeB_set) + +static bool js_ContactFeature_typeB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->typeB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->typeB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_typeB_get) + +static bool js_new_b2ContactFeature(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactFeature *result; + result = (b2ContactFeature *)new b2ContactFeature(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactFeature, __jsb_b2ContactFeature_class, js_delete_b2ContactFeature) + +static bool js_delete_b2ContactFeature(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactFeature) + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactFeature * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("indexA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexA), ctx); + } + + + json->getProperty("indexB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexB), ctx); + } + + + json->getProperty("typeA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->typeA), ctx); + } + + + json->getProperty("typeB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->typeB), ctx); + } + + + return ok; +} + + +bool js_register_b2ContactFeature(se::Object* obj) { + auto* cls = se::Class::create("ContactFeature", obj, nullptr, _SE(js_new_b2ContactFeature)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("indexA", _SE(js_ContactFeature_indexA_get), _SE(js_ContactFeature_indexA_set)); + cls->defineProperty("indexB", _SE(js_ContactFeature_indexB_get), _SE(js_ContactFeature_indexB_set)); + cls->defineProperty("typeA", _SE(js_ContactFeature_typeA_get), _SE(js_ContactFeature_typeA_set)); + cls->defineProperty("typeB", _SE(js_ContactFeature_typeB_get), _SE(js_ContactFeature_typeB_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactFeature)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactFeature_proto = cls->getProto(); + __jsb_b2ContactFeature_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactID_class = nullptr; +se::Object* __jsb_b2ContactID_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactID) + +static bool js_ContactID_cf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cf, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactID_cf_set) + +static bool js_ContactID_cf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cf, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cf, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactID_cf_get) + +static bool js_ContactID_key_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->key, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactID_key_set) + +static bool js_ContactID_key_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->key, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->key, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactID_key_get) + +static bool js_new_b2ContactID(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactID *result; + result = (b2ContactID *)new b2ContactID(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactID, __jsb_b2ContactID_class, js_delete_b2ContactID) + +static bool js_delete_b2ContactID(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactID) + +bool js_register_b2ContactID(se::Object* obj) { + auto* cls = se::Class::create("ContactID", obj, nullptr, _SE(js_new_b2ContactID)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("cf", _SE(js_ContactID_cf_get), _SE(js_ContactID_cf_set)); + cls->defineProperty("key", _SE(js_ContactID_key_get), _SE(js_ContactID_key_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactID)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactID_proto = cls->getProto(); + __jsb_b2ContactID_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ManifoldPoint_class = nullptr; +se::Object* __jsb_b2ManifoldPoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ManifoldPoint) + +static bool js_ManifoldPoint_localPoint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localPoint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_localPoint_set) + +static bool js_ManifoldPoint_localPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localPoint, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localPoint, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_localPoint_get) + +static bool js_ManifoldPoint_normalImpulse_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normalImpulse, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_normalImpulse_set) + +static bool js_ManifoldPoint_normalImpulse_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normalImpulse, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_normalImpulse_get) + +static bool js_ManifoldPoint_tangentImpulse_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tangentImpulse, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_tangentImpulse_set) + +static bool js_ManifoldPoint_tangentImpulse_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tangentImpulse, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_tangentImpulse_get) + +static bool js_ManifoldPoint_id_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->id, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_id_set) + +static bool js_ManifoldPoint_id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->id, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->id, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_id_get) + +static bool js_new_b2ManifoldPoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ManifoldPoint *result; + result = (b2ManifoldPoint *)new b2ManifoldPoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ManifoldPoint, __jsb_b2ManifoldPoint_class, js_delete_b2ManifoldPoint) + +static bool js_delete_b2ManifoldPoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ManifoldPoint) + +template<> +bool sevalue_to_native(const se::Value &from, b2ManifoldPoint * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localPoint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localPoint), ctx); + } + + + json->getProperty("normalImpulse", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normalImpulse), ctx); + } + + + json->getProperty("tangentImpulse", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tangentImpulse), ctx); + } + + + json->getProperty("id", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->id), ctx); + } + + + return ok; +} + + +bool js_register_b2ManifoldPoint(se::Object* obj) { + auto* cls = se::Class::create("ManifoldPoint", obj, nullptr, _SE(js_new_b2ManifoldPoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localPoint", _SE(js_ManifoldPoint_localPoint_get), _SE(js_ManifoldPoint_localPoint_set)); + cls->defineProperty("normalImpulse", _SE(js_ManifoldPoint_normalImpulse_get), _SE(js_ManifoldPoint_normalImpulse_set)); + cls->defineProperty("tangentImpulse", _SE(js_ManifoldPoint_tangentImpulse_get), _SE(js_ManifoldPoint_tangentImpulse_set)); + cls->defineProperty("id", _SE(js_ManifoldPoint_id_get), _SE(js_ManifoldPoint_id_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ManifoldPoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ManifoldPoint_proto = cls->getProto(); + __jsb_b2ManifoldPoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Manifold_class = nullptr; +se::Object* __jsb_b2Manifold_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Manifold) + +static bool js_Manifold_localNormal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localNormal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_localNormal_set) + +static bool js_Manifold_localNormal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localNormal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localNormal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_localNormal_get) + +static bool js_Manifold_localPoint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localPoint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_localPoint_set) + +static bool js_Manifold_localPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localPoint, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localPoint, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_localPoint_get) + +static bool js_Manifold_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_type_set) + +static bool js_Manifold_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_type_get) + +static bool js_Manifold_pointCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pointCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_pointCount_set) + +static bool js_Manifold_pointCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pointCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pointCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_pointCount_get) + +static bool js_new_b2Manifold(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Manifold *result; + result = (b2Manifold *)new b2Manifold(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Manifold, __jsb_b2Manifold_class, js_delete_b2Manifold) + +static bool js_delete_b2Manifold(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Manifold) + +template<> +bool sevalue_to_native(const se::Value &from, b2Manifold * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localNormal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localNormal), ctx); + } + + + json->getProperty("localPoint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localPoint), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("pointCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pointCount), ctx); + } + + + return ok; +} + + +bool js_register_b2Manifold(se::Object* obj) { + auto* cls = se::Class::create("Manifold", obj, nullptr, _SE(js_new_b2Manifold)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localNormal", _SE(js_Manifold_localNormal_get), _SE(js_Manifold_localNormal_set)); + cls->defineProperty("localPoint", _SE(js_Manifold_localPoint_get), _SE(js_Manifold_localPoint_set)); + cls->defineProperty("type", _SE(js_Manifold_type_get), _SE(js_Manifold_type_set)); + cls->defineProperty("pointCount", _SE(js_Manifold_pointCount_get), _SE(js_Manifold_pointCount_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Manifold)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Manifold_proto = cls->getProto(); + __jsb_b2Manifold_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WorldManifold_class = nullptr; +se::Object* __jsb_b2WorldManifold_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WorldManifold) + +static bool js_WorldManifold_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WorldManifold *arg1 = (b2WorldManifold *) NULL ; + b2Manifold *arg2 = (b2Manifold *) NULL ; + b2Transform *arg3 = 0 ; + float arg4 ; + b2Transform *arg5 = 0 ; + float arg6 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Initialize((b2Manifold const *)arg2,(b2Transform const &)*arg3,arg4,(b2Transform const &)*arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_WorldManifold_Initialize) + +static bool js_WorldManifold_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WorldManifold *arg1 = (b2WorldManifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WorldManifold_normal_set) + +static bool js_WorldManifold_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WorldManifold *arg1 = (b2WorldManifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WorldManifold_normal_get) + +static bool js_new_b2WorldManifold(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2WorldManifold *result; + result = (b2WorldManifold *)new b2WorldManifold(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2WorldManifold, __jsb_b2WorldManifold_class, js_delete_b2WorldManifold) + +static bool js_delete_b2WorldManifold(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WorldManifold) + +template<> +bool sevalue_to_native(const se::Value &from, b2WorldManifold * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("normal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normal), ctx); + } + + + return ok; +} + + +bool js_register_b2WorldManifold(se::Object* obj) { + auto* cls = se::Class::create("WorldManifold", obj, nullptr, _SE(js_new_b2WorldManifold)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("normal", _SE(js_WorldManifold_normal_get), _SE(js_WorldManifold_normal_set)); + + cls->defineFunction("Initialize", _SE(js_WorldManifold_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WorldManifold)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WorldManifold_proto = cls->getProto(); + __jsb_b2WorldManifold_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ClipVertex_class = nullptr; +se::Object* __jsb_b2ClipVertex_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ClipVertex) + +static bool js_ClipVertex_v_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ClipVertex_v_set) + +static bool js_ClipVertex_v_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->v, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ClipVertex_v_get) + +static bool js_ClipVertex_id_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->id, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ClipVertex_id_set) + +static bool js_ClipVertex_id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->id, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->id, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ClipVertex_id_get) + +static bool js_new_b2ClipVertex(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ClipVertex *result; + result = (b2ClipVertex *)new b2ClipVertex(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ClipVertex, __jsb_b2ClipVertex_class, js_delete_b2ClipVertex) + +static bool js_delete_b2ClipVertex(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ClipVertex) + +template<> +bool sevalue_to_native(const se::Value &from, b2ClipVertex * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("v", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->v), ctx); + } + + + json->getProperty("id", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->id), ctx); + } + + + return ok; +} + + +bool js_register_b2ClipVertex(se::Object* obj) { + auto* cls = se::Class::create("ClipVertex", obj, nullptr, _SE(js_new_b2ClipVertex)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("v", _SE(js_ClipVertex_v_get), _SE(js_ClipVertex_v_set)); + cls->defineProperty("id", _SE(js_ClipVertex_id_get), _SE(js_ClipVertex_id_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ClipVertex)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ClipVertex_proto = cls->getProto(); + __jsb_b2ClipVertex_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RayCastInput_class = nullptr; +se::Object* __jsb_b2RayCastInput_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RayCastInput) + +static bool js_RayCastInput_p1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->p1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RayCastInput_p1_set) + +static bool js_RayCastInput_p1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->p1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->p1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RayCastInput_p1_get) + +static bool js_RayCastInput_p2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->p2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RayCastInput_p2_set) + +static bool js_RayCastInput_p2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->p2, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->p2, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RayCastInput_p2_get) + +static bool js_RayCastInput_maxFraction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxFraction, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RayCastInput_maxFraction_set) + +static bool js_RayCastInput_maxFraction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxFraction, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RayCastInput_maxFraction_get) + +static bool js_new_b2RayCastInput(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RayCastInput *result; + result = (b2RayCastInput *)new b2RayCastInput(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RayCastInput, __jsb_b2RayCastInput_class, js_delete_b2RayCastInput) + +static bool js_delete_b2RayCastInput(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RayCastInput) + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastInput * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("p1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->p1), ctx); + } + + + json->getProperty("p2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->p2), ctx); + } + + + json->getProperty("maxFraction", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxFraction), ctx); + } + + + return ok; +} + + +bool js_register_b2RayCastInput(se::Object* obj) { + auto* cls = se::Class::create("RayCastInput", obj, nullptr, _SE(js_new_b2RayCastInput)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("p1", _SE(js_RayCastInput_p1_get), _SE(js_RayCastInput_p1_set)); + cls->defineProperty("p2", _SE(js_RayCastInput_p2_get), _SE(js_RayCastInput_p2_set)); + cls->defineProperty("maxFraction", _SE(js_RayCastInput_maxFraction_get), _SE(js_RayCastInput_maxFraction_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RayCastInput)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RayCastInput_proto = cls->getProto(); + __jsb_b2RayCastInput_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RayCastOutput_class = nullptr; +se::Object* __jsb_b2RayCastOutput_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RayCastOutput) + +static bool js_RayCastOutput_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RayCastOutput_normal_set) + +static bool js_RayCastOutput_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RayCastOutput_normal_get) + +static bool js_RayCastOutput_fraction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fraction, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RayCastOutput_fraction_set) + +static bool js_RayCastOutput_fraction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fraction, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RayCastOutput_fraction_get) + +static bool js_new_b2RayCastOutput(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RayCastOutput *result; + result = (b2RayCastOutput *)new b2RayCastOutput(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RayCastOutput, __jsb_b2RayCastOutput_class, js_delete_b2RayCastOutput) + +static bool js_delete_b2RayCastOutput(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RayCastOutput) + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastOutput * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("normal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normal), ctx); + } + + + json->getProperty("fraction", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->fraction), ctx); + } + + + return ok; +} + + +bool js_register_b2RayCastOutput(se::Object* obj) { + auto* cls = se::Class::create("RayCastOutput", obj, nullptr, _SE(js_new_b2RayCastOutput)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("normal", _SE(js_RayCastOutput_normal_get), _SE(js_RayCastOutput_normal_set)); + cls->defineProperty("fraction", _SE(js_RayCastOutput_fraction_get), _SE(js_RayCastOutput_fraction_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RayCastOutput)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RayCastOutput_proto = cls->getProto(); + __jsb_b2RayCastOutput_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2AABB_class = nullptr; +se::Object* __jsb_b2AABB_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2AABB) + +static bool js_AABB_IsValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2AABB const *)arg1)->IsValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_IsValid) + +static bool js_AABB_GetCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2AABB const *)arg1)->GetCenter(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_AABB_GetCenter) + +static bool js_AABB_GetExtents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2AABB const *)arg1)->GetExtents(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_AABB_GetExtents) + +static bool js_AABB_GetPerimeter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2AABB const *)arg1)->GetPerimeter(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_GetPerimeter) + +static bool js_AABB_Combine__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2AABB *arg2 = 0 ; + b2AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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)->Combine((b2AABB const &)*arg2); + + + return true; +} + +static bool js_AABB_Combine__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2AABB *arg2 = 0 ; + b2AABB *arg3 = 0 ; + b2AABB temp2 ; + b2AABB temp3 ; + + arg1 = SE_THIS_OBJECT(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)->Combine((b2AABB const &)*arg2,(b2AABB const &)*arg3); + + + return true; +} + +static bool js_AABB_Combine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_AABB_Combine__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_AABB_Combine__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_AABB_Combine) + +static bool js_AABB_Contains(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2AABB *arg2 = 0 ; + b2AABB 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(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)((b2AABB const *)arg1)->Contains((b2AABB const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_Contains) + +static bool js_AABB_RayCast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2RayCastOutput *arg2 = (b2RayCastOutput *) NULL ; + b2RayCastInput *arg3 = 0 ; + b2RayCastInput temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((b2AABB const *)arg1)->RayCast(arg2,(b2RayCastInput const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_RayCast) + +static bool js_AABB_lowerBound_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lowerBound, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_AABB_lowerBound_set) + +static bool js_AABB_lowerBound_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lowerBound, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->lowerBound, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_AABB_lowerBound_get) + +static bool js_AABB_upperBound_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->upperBound, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_AABB_upperBound_set) + +static bool js_AABB_upperBound_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->upperBound, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->upperBound, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_AABB_upperBound_get) + +static bool js_new_b2AABB(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2AABB *result; + result = (b2AABB *)new b2AABB(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2AABB, __jsb_b2AABB_class, js_delete_b2AABB) + +static bool js_delete_b2AABB(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2AABB) + +template<> +bool sevalue_to_native(const se::Value &from, b2AABB * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("lowerBound", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lowerBound), ctx); + } + + + json->getProperty("upperBound", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->upperBound), ctx); + } + + + return ok; +} + + +bool js_register_b2AABB(se::Object* obj) { + auto* cls = se::Class::create("AABB", obj, nullptr, _SE(js_new_b2AABB)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("lowerBound", _SE(js_AABB_lowerBound_get), _SE(js_AABB_lowerBound_set)); + cls->defineProperty("upperBound", _SE(js_AABB_upperBound_get), _SE(js_AABB_upperBound_set)); + + cls->defineFunction("IsValid", _SE(js_AABB_IsValid)); + cls->defineFunction("GetCenter", _SE(js_AABB_GetCenter)); + cls->defineFunction("GetExtents", _SE(js_AABB_GetExtents)); + cls->defineFunction("GetPerimeter", _SE(js_AABB_GetPerimeter)); + cls->defineFunction("Combine", _SE(js_AABB_Combine)); + cls->defineFunction("Contains", _SE(js_AABB_Contains)); + cls->defineFunction("RayCast", _SE(js_AABB_RayCast)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2AABB)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2AABB_proto = cls->getProto(); + __jsb_b2AABB_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_b2CollideCircles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2CircleShape *arg2 = (b2CircleShape *) NULL ; + b2Transform *arg3 = 0 ; + b2CircleShape *arg4 = (b2CircleShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollideCircles(arg1,(b2CircleShape const *)arg2,(b2Transform const &)*arg3,(b2CircleShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollideCircles) + +static bool js_b2CollidePolygonAndCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2PolygonShape *arg2 = (b2PolygonShape *) NULL ; + b2Transform *arg3 = 0 ; + b2CircleShape *arg4 = (b2CircleShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollidePolygonAndCircle(arg1,(b2PolygonShape const *)arg2,(b2Transform const &)*arg3,(b2CircleShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollidePolygonAndCircle) + +static bool js_b2CollidePolygons(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2PolygonShape *arg2 = (b2PolygonShape *) NULL ; + b2Transform *arg3 = 0 ; + b2PolygonShape *arg4 = (b2PolygonShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollidePolygons(arg1,(b2PolygonShape const *)arg2,(b2Transform const &)*arg3,(b2PolygonShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollidePolygons) + +static bool js_b2CollideEdgeAndCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2EdgeShape *arg2 = (b2EdgeShape *) NULL ; + b2Transform *arg3 = 0 ; + b2CircleShape *arg4 = (b2CircleShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollideEdgeAndCircle(arg1,(b2EdgeShape const *)arg2,(b2Transform const &)*arg3,(b2CircleShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollideEdgeAndCircle) + +static bool js_b2CollideEdgeAndPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2EdgeShape *arg2 = (b2EdgeShape *) NULL ; + b2Transform *arg3 = 0 ; + b2PolygonShape *arg4 = (b2PolygonShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollideEdgeAndPolygon(arg1,(b2EdgeShape const *)arg2,(b2Transform const &)*arg3,(b2PolygonShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollideEdgeAndPolygon) + +static bool js_b2ClipSegmentToLine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ClipVertex *arg1 ; + b2ClipVertex *arg2 ; + b2Vec2 *arg3 = 0 ; + float arg4 ; + int32 arg5 ; + b2Vec2 temp3 ; + int32 result; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = b2ClipSegmentToLine(arg1,(b2ClipVertex const (*))arg2,(b2Vec2 const &)*arg3,arg4,SWIG_STD_MOVE(arg5)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2ClipSegmentToLine) + +static bool js_b2TestOverlap__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Shape *arg1 = (b2Shape *) NULL ; + int32 arg2 ; + b2Shape *arg3 = (b2Shape *) NULL ; + int32 arg4 ; + b2Transform *arg5 = 0 ; + b2Transform *arg6 = 0 ; + b2Transform temp5 ; + b2Transform temp6 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[5], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (bool)b2TestOverlap((b2Shape const *)arg1,SWIG_STD_MOVE(arg2),(b2Shape const *)arg3,SWIG_STD_MOVE(arg4),(b2Transform const &)*arg5,(b2Transform const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2TestOverlap__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2AABB *arg1 = 0 ; + b2AABB *arg2 = 0 ; + b2AABB temp1 ; + b2AABB temp2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)b2TestOverlap((b2AABB const &)*arg1,(b2AABB const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2TestOverlap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_b2TestOverlap__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2TestOverlap__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2TestOverlap) + +se::Class* __jsb_b2Jacobian_class = nullptr; +se::Object* __jsb_b2Jacobian_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Jacobian) + +static bool js_Jacobian_linear_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linear, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Jacobian_linear_set) + +static bool js_Jacobian_linear_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linear, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linear, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Jacobian_linear_get) + +static bool js_Jacobian_angularA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Jacobian_angularA_set) + +static bool js_Jacobian_angularA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularA, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Jacobian_angularA_get) + +static bool js_Jacobian_angularB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Jacobian_angularB_set) + +static bool js_Jacobian_angularB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularB, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Jacobian_angularB_get) + +static bool js_new_b2Jacobian(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Jacobian *result; + result = (b2Jacobian *)new b2Jacobian(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Jacobian, __jsb_b2Jacobian_class, js_delete_b2Jacobian) + +static bool js_delete_b2Jacobian(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Jacobian) + +template<> +bool sevalue_to_native(const se::Value &from, b2Jacobian * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("linear", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linear), ctx); + } + + + json->getProperty("angularA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularA), ctx); + } + + + json->getProperty("angularB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularB), ctx); + } + + + return ok; +} + + +bool js_register_b2Jacobian(se::Object* obj) { + auto* cls = se::Class::create("Jacobian", obj, nullptr, _SE(js_new_b2Jacobian)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("linear", _SE(js_Jacobian_linear_get), _SE(js_Jacobian_linear_set)); + cls->defineProperty("angularA", _SE(js_Jacobian_angularA_get), _SE(js_Jacobian_angularA_set)); + cls->defineProperty("angularB", _SE(js_Jacobian_angularB_get), _SE(js_Jacobian_angularB_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Jacobian)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Jacobian_proto = cls->getProto(); + __jsb_b2Jacobian_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2JointEdge_class = nullptr; +se::Object* __jsb_b2JointEdge_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2JointEdge) + +static bool js_JointEdge_other_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->other, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_other_set) + +static bool js_JointEdge_other_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->other, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->other, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_other_get) + +static bool js_JointEdge_joint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->joint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_joint_set) + +static bool js_JointEdge_joint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->joint, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->joint, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_joint_get) + +static bool js_JointEdge_prev_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prev, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_prev_set) + +static bool js_JointEdge_prev_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prev, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prev, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_prev_get) + +static bool js_JointEdge_next_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->next, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_next_set) + +static bool js_JointEdge_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->next, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->next, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_next_get) + +static bool js_new_b2JointEdge(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2JointEdge *result; + result = (b2JointEdge *)new b2JointEdge(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2JointEdge, __jsb_b2JointEdge_class, js_delete_b2JointEdge) + +static bool js_delete_b2JointEdge(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2JointEdge) + +template<> +bool sevalue_to_native(const se::Value &from, b2JointEdge * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("other", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->other), ctx); + } + + + json->getProperty("joint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->joint), ctx); + } + + + json->getProperty("prev", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prev), ctx); + } + + + json->getProperty("next", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->next), ctx); + } + + + return ok; +} + + +bool js_register_b2JointEdge(se::Object* obj) { + auto* cls = se::Class::create("JointEdge", obj, nullptr, _SE(js_new_b2JointEdge)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("other", _SE(js_JointEdge_other_get), _SE(js_JointEdge_other_set)); + cls->defineProperty("joint", _SE(js_JointEdge_joint_get), _SE(js_JointEdge_joint_set)); + cls->defineProperty("prev", _SE(js_JointEdge_prev_get), _SE(js_JointEdge_prev_set)); + cls->defineProperty("next", _SE(js_JointEdge_next_get), _SE(js_JointEdge_next_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2JointEdge)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2JointEdge_proto = cls->getProto(); + __jsb_b2JointEdge_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2JointDef_class = nullptr; +se::Object* __jsb_b2JointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2JointDef) + +static bool js_new_b2JointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2JointDef *result; + result = (b2JointDef *)new b2JointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2JointDef, __jsb_b2JointDef_class, js_delete_b2JointDef) + +static bool js_JointDef_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_type_set) + +static bool js_JointDef_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_type_get) + +static bool js_JointDef_bodyA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bodyA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_bodyA_set) + +static bool js_JointDef_bodyA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bodyA, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bodyA, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_bodyA_get) + +static bool js_JointDef_bodyB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bodyB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_bodyB_set) + +static bool js_JointDef_bodyB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bodyB, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bodyB, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_bodyB_get) + +static bool js_JointDef_collideConnected_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->collideConnected); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_collideConnected_set) + +static bool js_JointDef_collideConnected_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->collideConnected, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_collideConnected_get) + +static bool js_delete_b2JointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2JointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2JointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("bodyA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bodyA), ctx); + } + + + json->getProperty("bodyB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bodyB), ctx); + } + + + json->getProperty("collideConnected", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->collideConnected), ctx); + } + + + return ok; +} + + +bool js_register_b2JointDef(se::Object* obj) { + auto* cls = se::Class::create("JointDef", obj, nullptr, _SE(js_new_b2JointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_JointDef_type_get), _SE(js_JointDef_type_set)); + cls->defineProperty("bodyA", _SE(js_JointDef_bodyA_get), _SE(js_JointDef_bodyA_set)); + cls->defineProperty("bodyB", _SE(js_JointDef_bodyB_get), _SE(js_JointDef_bodyB_set)); + cls->defineProperty("collideConnected", _SE(js_JointDef_collideConnected_get), _SE(js_JointDef_collideConnected_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2JointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2JointDef_proto = cls->getProto(); + __jsb_b2JointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Joint_class = nullptr; +se::Object* __jsb_b2Joint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Joint) + +static bool js_Joint_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2JointType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2JointType)((b2Joint const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetType) + +static bool js_Joint_GetBodyA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Body *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(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBodyA(); + + 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_Joint_GetBodyA) + +static bool js_Joint_GetBodyB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Body *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(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBodyB(); + + 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_Joint_GetBodyB) + +static bool js_Joint_GetAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Joint const *)arg1)->GetAnchorA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetAnchorA) + +static bool js_Joint_GetAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Joint const *)arg1)->GetAnchorB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetAnchorB) + +static bool js_Joint_GetReactionForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + float arg2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((b2Joint const *)arg1)->GetReactionForce(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetReactionForce) + +static bool js_Joint_GetReactionTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2Joint const *)arg1)->GetReactionTorque(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Joint_GetReactionTorque) + +static bool js_Joint_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetNext(); + + 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_Joint_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)((b2Joint const *)arg1)->GetNext(); + + 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_Joint_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Joint_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Joint_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Joint_GetNext) + +static bool js_Joint_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((b2Joint const *)arg1)->GetUserData(); + + 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_Joint_GetUserData) + +static bool js_Joint_SetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetUserData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Joint_SetUserData) + +static bool js_Joint_IsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Joint const *)arg1)->IsEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Joint_IsEnabled) + +static bool js_Joint_GetCollideConnected(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Joint const *)arg1)->GetCollideConnected(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Joint_GetCollideConnected) + +static bool js_Joint_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Dump(); + + + return true; +} +SE_BIND_FUNC(js_Joint_Dump) + +static bool js_Joint_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Joint_ShiftOrigin) + +bool js_register_b2Joint(se::Object* obj) { + auto* cls = se::Class::create("Joint", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetType", _SE(js_Joint_GetType)); + cls->defineFunction("GetBodyA", _SE(js_Joint_GetBodyA)); + cls->defineFunction("GetBodyB", _SE(js_Joint_GetBodyB)); + cls->defineFunction("GetAnchorA", _SE(js_Joint_GetAnchorA)); + cls->defineFunction("GetAnchorB", _SE(js_Joint_GetAnchorB)); + cls->defineFunction("GetReactionForce", _SE(js_Joint_GetReactionForce)); + cls->defineFunction("GetReactionTorque", _SE(js_Joint_GetReactionTorque)); + cls->defineFunction("GetNext", _SE(js_Joint_GetNext)); + cls->defineFunction("GetUserData", _SE(js_Joint_GetUserData)); + cls->defineFunction("SetUserData", _SE(js_Joint_SetUserData)); + cls->defineFunction("IsEnabled", _SE(js_Joint_IsEnabled)); + cls->defineFunction("GetCollideConnected", _SE(js_Joint_GetCollideConnected)); + cls->defineFunction("Dump", _SE(js_Joint_Dump)); + cls->defineFunction("ShiftOrigin", _SE(js_Joint_ShiftOrigin)); + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Joint_proto = cls->getProto(); + __jsb_b2Joint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ChainShape_class = nullptr; +se::Object* __jsb_b2ChainShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ChainShape) + +static bool js_new_b2ChainShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ChainShape *result; + result = (b2ChainShape *)new b2ChainShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ChainShape, __jsb_b2ChainShape_class, js_delete_b2ChainShape) + +static bool js_delete_b2ChainShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ChainShape) + +static bool js_ChainShape_Clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Clear(); + + + return true; +} +SE_BIND_FUNC(js_ChainShape_Clear) + +static bool js_ChainShape_GetChildEdge(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + b2EdgeShape *arg2 = (b2EdgeShape *) NULL ; + int32 arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + + ((b2ChainShape const *)arg1)->GetChildEdge(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_ChainShape_GetChildEdge) + +static bool js_ChainShape_m_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ChainShape_m_count_set) + +static bool js_ChainShape_m_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_count, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_count, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ChainShape_m_count_get) + +static bool js_ChainShape_m_prevVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_prevVertex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ChainShape_m_prevVertex_set) + +static bool js_ChainShape_m_prevVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_prevVertex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_prevVertex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ChainShape_m_prevVertex_get) + +static bool js_ChainShape_m_nextVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_nextVertex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ChainShape_m_nextVertex_set) + +static bool js_ChainShape_m_nextVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_nextVertex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_nextVertex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ChainShape_m_nextVertex_get) + +bool js_register_b2ChainShape(se::Object* obj) { + auto* cls = se::Class::create("ChainShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2ChainShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_count", _SE(js_ChainShape_m_count_get), _SE(js_ChainShape_m_count_set)); + cls->defineProperty("m_prevVertex", _SE(js_ChainShape_m_prevVertex_get), _SE(js_ChainShape_m_prevVertex_set)); + cls->defineProperty("m_nextVertex", _SE(js_ChainShape_m_nextVertex_get), _SE(js_ChainShape_m_nextVertex_set)); + + cls->defineFunction("Clear", _SE(js_ChainShape_Clear)); + cls->defineFunction("GetChildEdge", _SE(js_ChainShape_GetChildEdge)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ChainShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ChainShape_proto = cls->getProto(); + __jsb_b2ChainShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2CircleShape_class = nullptr; +se::Object* __jsb_b2CircleShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2CircleShape) + +static bool js_new_b2CircleShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2CircleShape *result; + result = (b2CircleShape *)new b2CircleShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2CircleShape, __jsb_b2CircleShape_class, js_delete_b2CircleShape) + +static bool js_CircleShape_m_p_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2CircleShape *arg1 = (b2CircleShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_p, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_CircleShape_m_p_set) + +static bool js_CircleShape_m_p_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2CircleShape *arg1 = (b2CircleShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_p, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_p, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_CircleShape_m_p_get) + +static bool js_delete_b2CircleShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2CircleShape) + +bool js_register_b2CircleShape(se::Object* obj) { + auto* cls = se::Class::create("CircleShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2CircleShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_p", _SE(js_CircleShape_m_p_get), _SE(js_CircleShape_m_p_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2CircleShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2CircleShape_proto = cls->getProto(); + __jsb_b2CircleShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2EdgeShape_class = nullptr; +se::Object* __jsb_b2EdgeShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2EdgeShape) + +static bool js_new_b2EdgeShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2EdgeShape *result; + result = (b2EdgeShape *)new b2EdgeShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2EdgeShape, __jsb_b2EdgeShape_class, js_delete_b2EdgeShape) + +static bool js_EdgeShape_SetOneSided(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->SetOneSided((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_EdgeShape_SetOneSided) + +static bool js_EdgeShape_SetTwoSided(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetTwoSided((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_EdgeShape_SetTwoSided) + +static bool js_EdgeShape_m_vertex1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex1_set) + +static bool js_EdgeShape_m_vertex1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex1_get) + +static bool js_EdgeShape_m_vertex2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex2_set) + +static bool js_EdgeShape_m_vertex2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex2, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex2, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex2_get) + +static bool js_EdgeShape_m_vertex0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex0_set) + +static bool js_EdgeShape_m_vertex0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex0, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex0, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex0_get) + +static bool js_EdgeShape_m_vertex3_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex3_set) + +static bool js_EdgeShape_m_vertex3_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex3, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex3, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex3_get) + +static bool js_EdgeShape_m_oneSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_oneSided); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_oneSided_set) + +static bool js_EdgeShape_m_oneSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_oneSided, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_oneSided_get) + +static bool js_delete_b2EdgeShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2EdgeShape) + +bool js_register_b2EdgeShape(se::Object* obj) { + auto* cls = se::Class::create("EdgeShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2EdgeShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_vertex1", _SE(js_EdgeShape_m_vertex1_get), _SE(js_EdgeShape_m_vertex1_set)); + cls->defineProperty("m_vertex2", _SE(js_EdgeShape_m_vertex2_get), _SE(js_EdgeShape_m_vertex2_set)); + cls->defineProperty("m_vertex0", _SE(js_EdgeShape_m_vertex0_get), _SE(js_EdgeShape_m_vertex0_set)); + cls->defineProperty("m_vertex3", _SE(js_EdgeShape_m_vertex3_get), _SE(js_EdgeShape_m_vertex3_set)); + cls->defineProperty("m_oneSided", _SE(js_EdgeShape_m_oneSided_get), _SE(js_EdgeShape_m_oneSided_set)); + + cls->defineFunction("SetOneSided", _SE(js_EdgeShape_SetOneSided)); + cls->defineFunction("SetTwoSided", _SE(js_EdgeShape_SetTwoSided)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2EdgeShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2EdgeShape_proto = cls->getProto(); + __jsb_b2EdgeShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PolygonShape_class = nullptr; +se::Object* __jsb_b2PolygonShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PolygonShape) + +static bool js_new_b2PolygonShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2PolygonShape *result; + result = (b2PolygonShape *)new b2PolygonShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2PolygonShape, __jsb_b2PolygonShape_class, js_delete_b2PolygonShape) + +static bool js_PolygonShape_SetAsBox__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + float arg2 ; + float arg3 ; + + arg1 = SE_THIS_OBJECT(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)->SetAsBox(arg2,arg3); + + + return true; +} + +static bool js_PolygonShape_SetAsBox__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + float arg2 ; + float arg3 ; + b2Vec2 *arg4 = 0 ; + float arg5 ; + b2Vec2 temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAsBox(arg2,arg3,(b2Vec2 const &)*arg4,arg5); + + + return true; +} + +static bool js_PolygonShape_SetAsBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_PolygonShape_SetAsBox__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_PolygonShape_SetAsBox__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_PolygonShape_SetAsBox) + +static bool js_PolygonShape_Validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PolygonShape *arg1 = (b2PolygonShape *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2PolygonShape const *)arg1)->Validate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PolygonShape_Validate) + +static bool js_PolygonShape_m_centroid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_centroid, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PolygonShape_m_centroid_set) + +static bool js_PolygonShape_m_centroid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_centroid, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_centroid, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PolygonShape_m_centroid_get) + +static bool js_PolygonShape_m_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PolygonShape_m_count_set) + +static bool js_PolygonShape_m_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_count, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_count, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PolygonShape_m_count_get) + +static bool js_delete_b2PolygonShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PolygonShape) + +bool js_register_b2PolygonShape(se::Object* obj) { + auto* cls = se::Class::create("PolygonShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2PolygonShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_centroid", _SE(js_PolygonShape_m_centroid_get), _SE(js_PolygonShape_m_centroid_set)); + cls->defineProperty("m_count", _SE(js_PolygonShape_m_count_get), _SE(js_PolygonShape_m_count_set)); + + cls->defineFunction("SetAsBox", _SE(js_PolygonShape_SetAsBox)); + cls->defineFunction("Validate", _SE(js_PolygonShape_Validate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PolygonShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PolygonShape_proto = cls->getProto(); + __jsb_b2PolygonShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Pair_class = nullptr; +se::Object* __jsb_b2Pair_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Pair) + +static bool js_Pair_proxyIdA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->proxyIdA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Pair_proxyIdA_set) + +static bool js_Pair_proxyIdA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->proxyIdA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->proxyIdA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Pair_proxyIdA_get) + +static bool js_Pair_proxyIdB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->proxyIdB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Pair_proxyIdB_set) + +static bool js_Pair_proxyIdB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->proxyIdB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->proxyIdB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Pair_proxyIdB_get) + +static bool js_new_b2Pair(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Pair *result; + result = (b2Pair *)new b2Pair(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Pair, __jsb_b2Pair_class, js_delete_b2Pair) + +static bool js_delete_b2Pair(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Pair) + +template<> +bool sevalue_to_native(const se::Value &from, b2Pair * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("proxyIdA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->proxyIdA), ctx); + } + + + json->getProperty("proxyIdB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->proxyIdB), ctx); + } + + + return ok; +} + + +bool js_register_b2Pair(se::Object* obj) { + auto* cls = se::Class::create("Pair", obj, nullptr, _SE(js_new_b2Pair)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("proxyIdA", _SE(js_Pair_proxyIdA_get), _SE(js_Pair_proxyIdA_set)); + cls->defineProperty("proxyIdB", _SE(js_Pair_proxyIdB_get), _SE(js_Pair_proxyIdB_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Pair)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Pair_proto = cls->getProto(); + __jsb_b2Pair_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2BroadPhase_class = nullptr; +se::Object* __jsb_b2BroadPhase_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2BroadPhase) + +static bool js_new_b2BroadPhase(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2BroadPhase *result; + result = (b2BroadPhase *)new b2BroadPhase(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2BroadPhase, __jsb_b2BroadPhase_class, js_delete_b2BroadPhase) + +static bool js_delete_b2BroadPhase(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2BroadPhase) + +static bool js_BroadPhase_CreateProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + b2AABB *arg2 = 0 ; + void *arg3 = (void *) NULL ; + b2AABB temp2 ; + int32 result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + result = (arg1)->CreateProxy((b2AABB const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_CreateProxy) + +static bool js_BroadPhase_DestroyProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->DestroyProxy(arg2); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_DestroyProxy) + +static bool js_BroadPhase_MoveProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + b2AABB *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + b2AABB temp3 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->MoveProxy(arg2,(b2AABB const &)*arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_MoveProxy) + +static bool js_BroadPhase_TouchProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->TouchProxy(arg2); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_TouchProxy) + +static bool js_BroadPhase_GetFatAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + b2AABB *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (b2AABB *) &((b2BroadPhase const *)arg1)->GetFatAABB(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_BroadPhase_GetFatAABB) + +static bool js_BroadPhase_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + void *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (void *)((b2BroadPhase const *)arg1)->GetUserData(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_BroadPhase_GetUserData) + +static bool js_BroadPhase_TestOverlap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + int32 arg3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((b2BroadPhase const *)arg1)->TestOverlap(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_TestOverlap) + +static bool js_BroadPhase_GetProxyCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2BroadPhase const *)arg1)->GetProxyCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetProxyCount) + +static bool js_BroadPhase_GetTreeHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2BroadPhase const *)arg1)->GetTreeHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetTreeHeight) + +static bool js_BroadPhase_GetTreeBalance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2BroadPhase const *)arg1)->GetTreeBalance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetTreeBalance) + +static bool js_BroadPhase_GetTreeQuality(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2BroadPhase const *)arg1)->GetTreeQuality(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetTreeQuality) + +static bool js_BroadPhase_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_ShiftOrigin) + +bool js_register_b2BroadPhase(se::Object* obj) { + auto* cls = se::Class::create("BroadPhase", obj, nullptr, _SE(js_new_b2BroadPhase)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("CreateProxy", _SE(js_BroadPhase_CreateProxy)); + cls->defineFunction("DestroyProxy", _SE(js_BroadPhase_DestroyProxy)); + cls->defineFunction("MoveProxy", _SE(js_BroadPhase_MoveProxy)); + cls->defineFunction("TouchProxy", _SE(js_BroadPhase_TouchProxy)); + cls->defineFunction("GetFatAABB", _SE(js_BroadPhase_GetFatAABB)); + cls->defineFunction("GetUserData", _SE(js_BroadPhase_GetUserData)); + cls->defineFunction("TestOverlap", _SE(js_BroadPhase_TestOverlap)); + cls->defineFunction("GetProxyCount", _SE(js_BroadPhase_GetProxyCount)); + cls->defineFunction("GetTreeHeight", _SE(js_BroadPhase_GetTreeHeight)); + cls->defineFunction("GetTreeBalance", _SE(js_BroadPhase_GetTreeBalance)); + cls->defineFunction("GetTreeQuality", _SE(js_BroadPhase_GetTreeQuality)); + cls->defineFunction("ShiftOrigin", _SE(js_BroadPhase_ShiftOrigin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2BroadPhase)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2BroadPhase_proto = cls->getProto(); + __jsb_b2BroadPhase_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2TreeNode_class = nullptr; +se::Object* __jsb_b2TreeNode_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2TreeNode) + +static bool js_TreeNode_IsLeaf(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2TreeNode const *)arg1)->IsLeaf(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_TreeNode_IsLeaf) + +static bool js_TreeNode_aabb_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->aabb, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_aabb_set) + +static bool js_TreeNode_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->aabb, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->aabb, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_aabb_get) + +static bool js_TreeNode_userData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->userData); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_userData_set) + +static bool js_TreeNode_userData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->userData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->userData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_userData_get) + +static bool js_TreeNode_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_parent_set) + +static bool js_TreeNode_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_parent_get) + +static bool js_TreeNode_next_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->next, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_next_set) + +static bool js_TreeNode_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->next, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->next, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_next_get) + +static bool js_TreeNode_child1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->child1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_child1_set) + +static bool js_TreeNode_child1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->child1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->child1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_child1_get) + +static bool js_TreeNode_child2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->child2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_child2_set) + +static bool js_TreeNode_child2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->child2, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->child2, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_child2_get) + +static bool js_TreeNode_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_height_set) + +static bool js_TreeNode_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->height, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_height_get) + +static bool js_TreeNode_moved_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->moved); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_moved_set) + +static bool js_TreeNode_moved_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->moved, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_moved_get) + +static bool js_new_b2TreeNode(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2TreeNode *result; + result = (b2TreeNode *)new b2TreeNode(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2TreeNode, __jsb_b2TreeNode_class, js_delete_b2TreeNode) + +static bool js_delete_b2TreeNode(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2TreeNode) + +template<> +bool sevalue_to_native(const se::Value &from, b2TreeNode * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("aabb", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->aabb), ctx); + } + + + json->getProperty("userData", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->userData), ctx); + } + + + json->getProperty("parent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->parent), ctx); + } + + + json->getProperty("next", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->next), ctx); + } + + + json->getProperty("child1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->child1), ctx); + } + + + json->getProperty("child2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->child2), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("moved", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->moved), ctx); + } + + + return ok; +} + + +bool js_register_b2TreeNode(se::Object* obj) { + auto* cls = se::Class::create("TreeNode", obj, nullptr, _SE(js_new_b2TreeNode)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("aabb", _SE(js_TreeNode_aabb_get), _SE(js_TreeNode_aabb_set)); + cls->defineProperty("userData", _SE(js_TreeNode_userData_get), _SE(js_TreeNode_userData_set)); + cls->defineProperty("parent", _SE(js_TreeNode_parent_get), _SE(js_TreeNode_parent_set)); + cls->defineProperty("next", _SE(js_TreeNode_next_get), _SE(js_TreeNode_next_set)); + cls->defineProperty("child1", _SE(js_TreeNode_child1_get), _SE(js_TreeNode_child1_set)); + cls->defineProperty("child2", _SE(js_TreeNode_child2_get), _SE(js_TreeNode_child2_set)); + cls->defineProperty("height", _SE(js_TreeNode_height_get), _SE(js_TreeNode_height_set)); + cls->defineProperty("moved", _SE(js_TreeNode_moved_get), _SE(js_TreeNode_moved_set)); + + cls->defineFunction("IsLeaf", _SE(js_TreeNode_IsLeaf)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2TreeNode)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2TreeNode_proto = cls->getProto(); + __jsb_b2TreeNode_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DynamicTree_class = nullptr; +se::Object* __jsb_b2DynamicTree_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DynamicTree) + +static bool js_new_b2DynamicTree(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2DynamicTree *result; + result = (b2DynamicTree *)new b2DynamicTree(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2DynamicTree, __jsb_b2DynamicTree_class, js_delete_b2DynamicTree) + +static bool js_delete_b2DynamicTree(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DynamicTree) + +static bool js_DynamicTree_CreateProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + b2AABB *arg2 = 0 ; + void *arg3 = (void *) NULL ; + b2AABB temp2 ; + int32 result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + result = (arg1)->CreateProxy((b2AABB const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_CreateProxy) + +static bool js_DynamicTree_DestroyProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->DestroyProxy(arg2); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_DestroyProxy) + +static bool js_DynamicTree_MoveProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + b2AABB *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + b2AABB temp3 ; + b2Vec2 temp4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (bool)(arg1)->MoveProxy(arg2,(b2AABB const &)*arg3,(b2Vec2 const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_MoveProxy) + +static bool js_DynamicTree_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + void *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (void *)((b2DynamicTree const *)arg1)->GetUserData(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_DynamicTree_GetUserData) + +static bool js_DynamicTree_WasMoved(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((b2DynamicTree const *)arg1)->WasMoved(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_WasMoved) + +static bool js_DynamicTree_ClearMoved(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->ClearMoved(arg2); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_ClearMoved) + +static bool js_DynamicTree_GetFatAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + b2AABB *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (b2AABB *) &((b2DynamicTree const *)arg1)->GetFatAABB(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_DynamicTree_GetFatAABB) + +static bool js_DynamicTree_Validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ((b2DynamicTree const *)arg1)->Validate(); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_Validate) + +static bool js_DynamicTree_GetHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2DynamicTree const *)arg1)->GetHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_GetHeight) + +static bool js_DynamicTree_GetMaxBalance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2DynamicTree const *)arg1)->GetMaxBalance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_GetMaxBalance) + +static bool js_DynamicTree_GetAreaRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DynamicTree const *)arg1)->GetAreaRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_GetAreaRatio) + +static bool js_DynamicTree_RebuildBottomUp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->RebuildBottomUp(); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_RebuildBottomUp) + +static bool js_DynamicTree_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_ShiftOrigin) + +bool js_register_b2DynamicTree(se::Object* obj) { + auto* cls = se::Class::create("DynamicTree", obj, nullptr, _SE(js_new_b2DynamicTree)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("CreateProxy", _SE(js_DynamicTree_CreateProxy)); + cls->defineFunction("DestroyProxy", _SE(js_DynamicTree_DestroyProxy)); + cls->defineFunction("MoveProxy", _SE(js_DynamicTree_MoveProxy)); + cls->defineFunction("GetUserData", _SE(js_DynamicTree_GetUserData)); + cls->defineFunction("WasMoved", _SE(js_DynamicTree_WasMoved)); + cls->defineFunction("ClearMoved", _SE(js_DynamicTree_ClearMoved)); + cls->defineFunction("GetFatAABB", _SE(js_DynamicTree_GetFatAABB)); + cls->defineFunction("Validate", _SE(js_DynamicTree_Validate)); + cls->defineFunction("GetHeight", _SE(js_DynamicTree_GetHeight)); + cls->defineFunction("GetMaxBalance", _SE(js_DynamicTree_GetMaxBalance)); + cls->defineFunction("GetAreaRatio", _SE(js_DynamicTree_GetAreaRatio)); + cls->defineFunction("RebuildBottomUp", _SE(js_DynamicTree_RebuildBottomUp)); + cls->defineFunction("ShiftOrigin", _SE(js_DynamicTree_ShiftOrigin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DynamicTree)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DynamicTree_proto = cls->getProto(); + __jsb_b2DynamicTree_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2BodyDef_class = nullptr; +se::Object* __jsb_b2BodyDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2BodyDef) + +static bool js_new_b2BodyDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2BodyDef *result; + result = (b2BodyDef *)new b2BodyDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2BodyDef, __jsb_b2BodyDef_class, js_delete_b2BodyDef) + +static bool js_BodyDef_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_type_set) + +static bool js_BodyDef_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_type_get) + +static bool js_BodyDef_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_position_set) + +static bool js_BodyDef_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_position_get) + +static bool js_BodyDef_angle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_angle_set) + +static bool js_BodyDef_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_angle_get) + +static bool js_BodyDef_linearVelocity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linearVelocity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_linearVelocity_set) + +static bool js_BodyDef_linearVelocity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linearVelocity, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linearVelocity, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_linearVelocity_get) + +static bool js_BodyDef_angularVelocity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularVelocity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_angularVelocity_set) + +static bool js_BodyDef_angularVelocity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularVelocity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_angularVelocity_get) + +static bool js_BodyDef_linearDamping_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linearDamping, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_linearDamping_set) + +static bool js_BodyDef_linearDamping_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linearDamping, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_linearDamping_get) + +static bool js_BodyDef_angularDamping_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularDamping, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_angularDamping_set) + +static bool js_BodyDef_angularDamping_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularDamping, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_angularDamping_get) + +static bool js_BodyDef_allowSleep_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->allowSleep); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_allowSleep_set) + +static bool js_BodyDef_allowSleep_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->allowSleep, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_allowSleep_get) + +static bool js_BodyDef_awake_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->awake); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_awake_set) + +static bool js_BodyDef_awake_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->awake, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_awake_get) + +static bool js_BodyDef_fixedRotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fixedRotation); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_fixedRotation_set) + +static bool js_BodyDef_fixedRotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fixedRotation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_fixedRotation_get) + +static bool js_BodyDef_bullet_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bullet); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_bullet_set) + +static bool js_BodyDef_bullet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bullet, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_bullet_get) + +static bool js_BodyDef_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_enabled_set) + +static bool js_BodyDef_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_enabled_get) + +static bool js_BodyDef_gravityScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->gravityScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_gravityScale_set) + +static bool js_BodyDef_gravityScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->gravityScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_gravityScale_get) + +static bool js_delete_b2BodyDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2BodyDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2BodyDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("position", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->position), ctx); + } + + + json->getProperty("angle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angle), ctx); + } + + + json->getProperty("linearVelocity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linearVelocity), ctx); + } + + + json->getProperty("angularVelocity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularVelocity), ctx); + } + + + json->getProperty("linearDamping", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linearDamping), ctx); + } + + + json->getProperty("angularDamping", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularDamping), ctx); + } + + + json->getProperty("allowSleep", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->allowSleep), ctx); + } + + + json->getProperty("awake", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->awake), ctx); + } + + + json->getProperty("fixedRotation", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->fixedRotation), ctx); + } + + + json->getProperty("bullet", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bullet), ctx); + } + + + json->getProperty("enabled", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enabled), ctx); + } + + + json->getProperty("gravityScale", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->gravityScale), ctx); + } + + + return ok; +} + + +bool js_register_b2BodyDef(se::Object* obj) { + auto* cls = se::Class::create("BodyDef", obj, nullptr, _SE(js_new_b2BodyDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_BodyDef_type_get), _SE(js_BodyDef_type_set)); + cls->defineProperty("position", _SE(js_BodyDef_position_get), _SE(js_BodyDef_position_set)); + cls->defineProperty("angle", _SE(js_BodyDef_angle_get), _SE(js_BodyDef_angle_set)); + cls->defineProperty("linearVelocity", _SE(js_BodyDef_linearVelocity_get), _SE(js_BodyDef_linearVelocity_set)); + cls->defineProperty("angularVelocity", _SE(js_BodyDef_angularVelocity_get), _SE(js_BodyDef_angularVelocity_set)); + cls->defineProperty("linearDamping", _SE(js_BodyDef_linearDamping_get), _SE(js_BodyDef_linearDamping_set)); + cls->defineProperty("angularDamping", _SE(js_BodyDef_angularDamping_get), _SE(js_BodyDef_angularDamping_set)); + cls->defineProperty("allowSleep", _SE(js_BodyDef_allowSleep_get), _SE(js_BodyDef_allowSleep_set)); + cls->defineProperty("awake", _SE(js_BodyDef_awake_get), _SE(js_BodyDef_awake_set)); + cls->defineProperty("fixedRotation", _SE(js_BodyDef_fixedRotation_get), _SE(js_BodyDef_fixedRotation_set)); + cls->defineProperty("bullet", _SE(js_BodyDef_bullet_get), _SE(js_BodyDef_bullet_set)); + cls->defineProperty("enabled", _SE(js_BodyDef_enabled_get), _SE(js_BodyDef_enabled_set)); + cls->defineProperty("gravityScale", _SE(js_BodyDef_gravityScale_get), _SE(js_BodyDef_gravityScale_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2BodyDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2BodyDef_proto = cls->getProto(); + __jsb_b2BodyDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Body_class = nullptr; +se::Object* __jsb_b2Body_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Body) + +static bool js_Body_CreateFixture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2FixtureDef *arg2 = (b2FixtureDef *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Fixture *)(arg1)->CreateFixture((b2FixtureDef 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; +} + +static bool js_Body_CreateFixture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Shape *arg2 = (b2Shape *) NULL ; + float arg3 ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (b2Fixture *)(arg1)->CreateFixture((b2Shape 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; +} + +static bool js_Body_CreateFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_Body_CreateFixture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_Body_CreateFixture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_CreateFixture) + +static bool js_Body_DestroyFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->DestroyFixture(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_DestroyFixture) + +static bool js_Body_SetTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetTransform((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_SetTransform) + +static bool js_Body_GetTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Transform *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(s); + if (nullptr == arg1) return true; + result = (b2Transform *) &((b2Body const *)arg1)->GetTransform(); + + 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_Body_GetTransform) + +static bool js_Body_GetPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetPosition(); + + 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_Body_GetPosition) + +static bool js_Body_GetAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetAngle) + +static bool js_Body_GetWorldCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetWorldCenter(); + + 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_Body_GetWorldCenter) + +static bool js_Body_GetLocalCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetLocalCenter(); + + 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_Body_GetLocalCenter) + +static bool js_Body_SetLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLinearVelocity((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetLinearVelocity) + +static bool js_Body_GetLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetLinearVelocity(); + + 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_Body_GetLinearVelocity) + +static bool js_Body_SetAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAngularVelocity(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetAngularVelocity) + +static bool js_Body_GetAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetAngularVelocity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetAngularVelocity) + +static bool js_Body_ApplyForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + bool arg4 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyForce((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyForce) + +static bool js_Body_ApplyForceToCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + bool arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ApplyForceToCenter((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyForceToCenter) + +static bool js_Body_ApplyTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyTorque(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyTorque) + +static bool js_Body_ApplyLinearImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + bool arg4 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyLinearImpulse((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyLinearImpulse) + +static bool js_Body_ApplyLinearImpulseToCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + bool arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ApplyLinearImpulseToCenter((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyLinearImpulseToCenter) + +static bool js_Body_ApplyAngularImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyAngularImpulse(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyAngularImpulse) + +static bool js_Body_GetMass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetMass(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetMass) + +static bool js_Body_GetInertia(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetInertia(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetInertia) + +static bool js_Body_GetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Body const *)arg1)->GetMassData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_GetMassData) + +static bool js_Body_SetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMassData((b2MassData const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetMassData) + +static bool js_Body_ResetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ResetMassData(); + + + return true; +} +SE_BIND_FUNC(js_Body_ResetMassData) + +static bool js_Body_GetWorldPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetWorldPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetWorldPoint) + +static bool js_Body_GetWorldVector(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetWorldVector((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetWorldVector) + +static bool js_Body_GetLocalPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLocalPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLocalPoint) + +static bool js_Body_GetLocalVector(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLocalVector((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLocalVector) + +static bool js_Body_GetLinearVelocityFromWorldPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLinearVelocityFromWorldPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLinearVelocityFromWorldPoint) + +static bool js_Body_GetLinearVelocityFromLocalPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLinearVelocityFromLocalPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLinearVelocityFromLocalPoint) + +static bool js_Body_GetLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetLinearDamping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetLinearDamping) + +static bool js_Body_SetLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetLinearDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetLinearDamping) + +static bool js_Body_GetAngularDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetAngularDamping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetAngularDamping) + +static bool js_Body_SetAngularDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAngularDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetAngularDamping) + +static bool js_Body_GetGravityScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetGravityScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetGravityScale) + +static bool js_Body_SetGravityScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetGravityScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetGravityScale) + +static bool js_Body_SetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2BodyType arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->SetType(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetType) + +static bool js_Body_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2BodyType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2BodyType)((b2Body const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetType) + +static bool js_Body_SetBullet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetBullet(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetBullet) + +static bool js_Body_IsBullet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsBullet(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsBullet) + +static bool js_Body_SetSleepingAllowed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSleepingAllowed(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetSleepingAllowed) + +static bool js_Body_IsSleepingAllowed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsSleepingAllowed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsSleepingAllowed) + +static bool js_Body_SetAwake(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAwake(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetAwake) + +static bool js_Body_IsAwake(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsAwake(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsAwake) + +static bool js_Body_SetEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetEnabled) + +static bool js_Body_IsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsEnabled) + +static bool js_Body_SetFixedRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFixedRotation(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetFixedRotation) + +static bool js_Body_IsFixedRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsFixedRotation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsFixedRotation) + +static bool js_Body_GetFixtureList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetFixtureList(); + + 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_Body_GetFixtureList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Body const *)arg1)->GetFixtureList(); + + 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_Body_GetFixtureList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetFixtureList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetFixtureList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetFixtureList) + +static bool js_Body_GetJointList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2JointEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2JointEdge *)(arg1)->GetJointList(); + + 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_Body_GetJointList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2JointEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2JointEdge *)((b2Body const *)arg1)->GetJointList(); + + 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_Body_GetJointList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetJointList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetJointList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetJointList) + +static bool js_Body_GetContactList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2ContactEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2ContactEdge *)(arg1)->GetContactList(); + + 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_Body_GetContactList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2ContactEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2ContactEdge *)((b2Body const *)arg1)->GetContactList(); + + 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_Body_GetContactList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetContactList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetContactList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetContactList) + +static bool js_Body_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetNext(); + + 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_Body_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)((b2Body const *)arg1)->GetNext(); + + 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_Body_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetNext) + +static bool js_Body_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((b2Body const *)arg1)->GetUserData(); + + 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_Body_GetUserData) + +static bool js_Body_SetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetUserData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetUserData) + +static bool js_Body_GetWorld__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2World *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2World *)(arg1)->GetWorld(); + + 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_Body_GetWorld__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2World *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2World *)((b2Body const *)arg1)->GetWorld(); + + 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_Body_GetWorld(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetWorld__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetWorld__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetWorld) + +static bool js_Body_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Dump(); + + + return true; +} +SE_BIND_FUNC(js_Body_Dump) + +bool js_register_b2Body(se::Object* obj) { + auto* cls = se::Class::create("Body", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("CreateFixture", _SE(js_Body_CreateFixture)); + cls->defineFunction("DestroyFixture", _SE(js_Body_DestroyFixture)); + cls->defineFunction("SetTransform", _SE(js_Body_SetTransform)); + cls->defineFunction("GetTransform", _SE(js_Body_GetTransform)); + cls->defineFunction("GetPosition", _SE(js_Body_GetPosition)); + cls->defineFunction("GetAngle", _SE(js_Body_GetAngle)); + cls->defineFunction("GetWorldCenter", _SE(js_Body_GetWorldCenter)); + cls->defineFunction("GetLocalCenter", _SE(js_Body_GetLocalCenter)); + cls->defineFunction("SetLinearVelocity", _SE(js_Body_SetLinearVelocity)); + cls->defineFunction("GetLinearVelocity", _SE(js_Body_GetLinearVelocity)); + cls->defineFunction("SetAngularVelocity", _SE(js_Body_SetAngularVelocity)); + cls->defineFunction("GetAngularVelocity", _SE(js_Body_GetAngularVelocity)); + cls->defineFunction("ApplyForce", _SE(js_Body_ApplyForce)); + cls->defineFunction("ApplyForceToCenter", _SE(js_Body_ApplyForceToCenter)); + cls->defineFunction("ApplyTorque", _SE(js_Body_ApplyTorque)); + cls->defineFunction("ApplyLinearImpulse", _SE(js_Body_ApplyLinearImpulse)); + cls->defineFunction("ApplyLinearImpulseToCenter", _SE(js_Body_ApplyLinearImpulseToCenter)); + cls->defineFunction("ApplyAngularImpulse", _SE(js_Body_ApplyAngularImpulse)); + cls->defineFunction("GetMass", _SE(js_Body_GetMass)); + cls->defineFunction("GetInertia", _SE(js_Body_GetInertia)); + cls->defineFunction("GetMassData", _SE(js_Body_GetMassData)); + cls->defineFunction("SetMassData", _SE(js_Body_SetMassData)); + cls->defineFunction("ResetMassData", _SE(js_Body_ResetMassData)); + cls->defineFunction("GetWorldPoint", _SE(js_Body_GetWorldPoint)); + cls->defineFunction("GetWorldVector", _SE(js_Body_GetWorldVector)); + cls->defineFunction("GetLocalPoint", _SE(js_Body_GetLocalPoint)); + cls->defineFunction("GetLocalVector", _SE(js_Body_GetLocalVector)); + cls->defineFunction("GetLinearVelocityFromWorldPoint", _SE(js_Body_GetLinearVelocityFromWorldPoint)); + cls->defineFunction("GetLinearVelocityFromLocalPoint", _SE(js_Body_GetLinearVelocityFromLocalPoint)); + cls->defineFunction("GetLinearDamping", _SE(js_Body_GetLinearDamping)); + cls->defineFunction("SetLinearDamping", _SE(js_Body_SetLinearDamping)); + cls->defineFunction("GetAngularDamping", _SE(js_Body_GetAngularDamping)); + cls->defineFunction("SetAngularDamping", _SE(js_Body_SetAngularDamping)); + cls->defineFunction("GetGravityScale", _SE(js_Body_GetGravityScale)); + cls->defineFunction("SetGravityScale", _SE(js_Body_SetGravityScale)); + cls->defineFunction("SetType", _SE(js_Body_SetType)); + cls->defineFunction("GetType", _SE(js_Body_GetType)); + cls->defineFunction("SetBullet", _SE(js_Body_SetBullet)); + cls->defineFunction("IsBullet", _SE(js_Body_IsBullet)); + cls->defineFunction("SetSleepingAllowed", _SE(js_Body_SetSleepingAllowed)); + cls->defineFunction("IsSleepingAllowed", _SE(js_Body_IsSleepingAllowed)); + cls->defineFunction("SetAwake", _SE(js_Body_SetAwake)); + cls->defineFunction("IsAwake", _SE(js_Body_IsAwake)); + cls->defineFunction("SetEnabled", _SE(js_Body_SetEnabled)); + cls->defineFunction("IsEnabled", _SE(js_Body_IsEnabled)); + cls->defineFunction("SetFixedRotation", _SE(js_Body_SetFixedRotation)); + cls->defineFunction("IsFixedRotation", _SE(js_Body_IsFixedRotation)); + cls->defineFunction("GetFixtureList", _SE(js_Body_GetFixtureList)); + cls->defineFunction("GetJointList", _SE(js_Body_GetJointList)); + cls->defineFunction("GetContactList", _SE(js_Body_GetContactList)); + cls->defineFunction("GetNext", _SE(js_Body_GetNext)); + cls->defineFunction("GetUserData", _SE(js_Body_GetUserData)); + cls->defineFunction("SetUserData", _SE(js_Body_SetUserData)); + cls->defineFunction("GetWorld", _SE(js_Body_GetWorld)); + cls->defineFunction("Dump", _SE(js_Body_Dump)); + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Body_proto = cls->getProto(); + __jsb_b2Body_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_b2MixFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)b2MixFriction(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2MixFriction) + +static bool js_b2MixRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)b2MixRestitution(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2MixRestitution) + +se::Class* __jsb_b2ContactEdge_class = nullptr; +se::Object* __jsb_b2ContactEdge_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactEdge) + +static bool js_ContactEdge_other_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->other, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_other_set) + +static bool js_ContactEdge_other_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->other, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->other, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_other_get) + +static bool js_ContactEdge_contact_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->contact, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_contact_set) + +static bool js_ContactEdge_contact_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->contact, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->contact, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_contact_get) + +static bool js_ContactEdge_prev_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prev, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_prev_set) + +static bool js_ContactEdge_prev_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prev, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prev, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_prev_get) + +static bool js_ContactEdge_next_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->next, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_next_set) + +static bool js_ContactEdge_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->next, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->next, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_next_get) + +static bool js_new_b2ContactEdge(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactEdge *result; + result = (b2ContactEdge *)new b2ContactEdge(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactEdge, __jsb_b2ContactEdge_class, js_delete_b2ContactEdge) + +static bool js_delete_b2ContactEdge(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactEdge) + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactEdge * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("other", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->other), ctx); + } + + + json->getProperty("contact", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->contact), ctx); + } + + + json->getProperty("prev", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prev), ctx); + } + + + json->getProperty("next", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->next), ctx); + } + + + return ok; +} + + +bool js_register_b2ContactEdge(se::Object* obj) { + auto* cls = se::Class::create("ContactEdge", obj, nullptr, _SE(js_new_b2ContactEdge)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("other", _SE(js_ContactEdge_other_get), _SE(js_ContactEdge_other_set)); + cls->defineProperty("contact", _SE(js_ContactEdge_contact_get), _SE(js_ContactEdge_contact_set)); + cls->defineProperty("prev", _SE(js_ContactEdge_prev_get), _SE(js_ContactEdge_prev_set)); + cls->defineProperty("next", _SE(js_ContactEdge_next_get), _SE(js_ContactEdge_next_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactEdge)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactEdge_proto = cls->getProto(); + __jsb_b2ContactEdge_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Contact_class = nullptr; +se::Object* __jsb_b2Contact_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Contact) + +static bool js_Contact_GetManifold__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Manifold *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Manifold *)(arg1)->GetManifold(); + + 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_Contact_GetManifold__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Manifold *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Manifold *)((b2Contact const *)arg1)->GetManifold(); + + 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_Contact_GetManifold(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetManifold__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetManifold__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetManifold) + +static bool js_Contact_IsTouching(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Contact const *)arg1)->IsTouching(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_IsTouching) + +static bool js_Contact_SetEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetEnabled) + +static bool js_Contact_IsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Contact const *)arg1)->IsEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_IsEnabled) + +static bool js_Contact_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)(arg1)->GetNext(); + + 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_Contact_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)((b2Contact const *)arg1)->GetNext(); + + 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_Contact_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetNext) + +static bool js_Contact_GetFixtureA__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetFixtureA(); + + 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_Contact_GetFixtureA__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Contact const *)arg1)->GetFixtureA(); + + 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_Contact_GetFixtureA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetFixtureA__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetFixtureA__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetFixtureA) + +static bool js_Contact_GetChildIndexA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Contact const *)arg1)->GetChildIndexA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Contact_GetChildIndexA) + +static bool js_Contact_GetFixtureB__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetFixtureB(); + + 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_Contact_GetFixtureB__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Contact const *)arg1)->GetFixtureB(); + + 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_Contact_GetFixtureB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetFixtureB__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetFixtureB__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetFixtureB) + +static bool js_Contact_GetChildIndexB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Contact const *)arg1)->GetChildIndexB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Contact_GetChildIndexB) + +static bool js_Contact_SetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFriction(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetFriction) + +static bool js_Contact_GetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Contact const *)arg1)->GetFriction(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_GetFriction) + +static bool js_Contact_ResetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ResetFriction(); + + + return true; +} +SE_BIND_FUNC(js_Contact_ResetFriction) + +static bool js_Contact_SetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetRestitution) + +static bool js_Contact_GetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Contact const *)arg1)->GetRestitution(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_GetRestitution) + +static bool js_Contact_ResetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ResetRestitution(); + + + return true; +} +SE_BIND_FUNC(js_Contact_ResetRestitution) + +static bool js_Contact_SetTangentSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetTangentSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetTangentSpeed) + +static bool js_Contact_GetTangentSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Contact const *)arg1)->GetTangentSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_GetTangentSpeed) + +static bool js_Contact_Evaluate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Manifold *arg2 = (b2Manifold *) NULL ; + b2Transform *arg3 = 0 ; + b2Transform *arg4 = 0 ; + b2Transform temp3 ; + b2Transform temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->Evaluate(arg2,(b2Transform const &)*arg3,(b2Transform const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Contact_Evaluate) + +bool js_register_b2Contact(se::Object* obj) { + auto* cls = se::Class::create("Contact", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetManifold", _SE(js_Contact_GetManifold)); + cls->defineFunction("IsTouching", _SE(js_Contact_IsTouching)); + cls->defineFunction("SetEnabled", _SE(js_Contact_SetEnabled)); + cls->defineFunction("IsEnabled", _SE(js_Contact_IsEnabled)); + cls->defineFunction("GetNext", _SE(js_Contact_GetNext)); + cls->defineFunction("GetFixtureA", _SE(js_Contact_GetFixtureA)); + cls->defineFunction("GetChildIndexA", _SE(js_Contact_GetChildIndexA)); + cls->defineFunction("GetFixtureB", _SE(js_Contact_GetFixtureB)); + cls->defineFunction("GetChildIndexB", _SE(js_Contact_GetChildIndexB)); + cls->defineFunction("SetFriction", _SE(js_Contact_SetFriction)); + cls->defineFunction("GetFriction", _SE(js_Contact_GetFriction)); + cls->defineFunction("ResetFriction", _SE(js_Contact_ResetFriction)); + cls->defineFunction("SetRestitution", _SE(js_Contact_SetRestitution)); + cls->defineFunction("GetRestitution", _SE(js_Contact_GetRestitution)); + cls->defineFunction("ResetRestitution", _SE(js_Contact_ResetRestitution)); + cls->defineFunction("SetTangentSpeed", _SE(js_Contact_SetTangentSpeed)); + cls->defineFunction("GetTangentSpeed", _SE(js_Contact_GetTangentSpeed)); + cls->defineFunction("Evaluate", _SE(js_Contact_Evaluate)); + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Contact_proto = cls->getProto(); + __jsb_b2Contact_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Filter_class = nullptr; +se::Object* __jsb_b2Filter_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Filter) + +static bool js_new_b2Filter(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Filter *result; + result = (b2Filter *)new b2Filter(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Filter, __jsb_b2Filter_class, js_delete_b2Filter) + +static bool js_Filter_categoryBits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->categoryBits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Filter_categoryBits_set) + +static bool js_Filter_categoryBits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->categoryBits, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->categoryBits, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Filter_categoryBits_get) + +static bool js_Filter_maskBits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maskBits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Filter_maskBits_set) + +static bool js_Filter_maskBits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maskBits, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maskBits, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Filter_maskBits_get) + +static bool js_Filter_groupIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Filter_groupIndex_set) + +static bool js_Filter_groupIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->groupIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Filter_groupIndex_get) + +static bool js_delete_b2Filter(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Filter) + +template<> +bool sevalue_to_native(const se::Value &from, b2Filter * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("categoryBits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->categoryBits), ctx); + } + + + json->getProperty("maskBits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maskBits), ctx); + } + + + json->getProperty("groupIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupIndex), ctx); + } + + + return ok; +} + + +bool js_register_b2Filter(se::Object* obj) { + auto* cls = se::Class::create("Filter", obj, nullptr, _SE(js_new_b2Filter)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("categoryBits", _SE(js_Filter_categoryBits_get), _SE(js_Filter_categoryBits_set)); + cls->defineProperty("maskBits", _SE(js_Filter_maskBits_get), _SE(js_Filter_maskBits_set)); + cls->defineProperty("groupIndex", _SE(js_Filter_groupIndex_get), _SE(js_Filter_groupIndex_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Filter)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Filter_proto = cls->getProto(); + __jsb_b2Filter_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FixtureDef_class = nullptr; +se::Object* __jsb_b2FixtureDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FixtureDef) + +static bool js_new_b2FixtureDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2FixtureDef *result; + result = (b2FixtureDef *)new b2FixtureDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2FixtureDef, __jsb_b2FixtureDef_class, js_delete_b2FixtureDef) + +static bool js_FixtureDef_shape_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shape, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_shape_set) + +static bool js_FixtureDef_shape_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shape, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shape, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_shape_get) + +static bool js_FixtureDef_friction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->friction, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_friction_set) + +static bool js_FixtureDef_friction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->friction, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_friction_get) + +static bool js_FixtureDef_restitution_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->restitution, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_restitution_set) + +static bool js_FixtureDef_restitution_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->restitution, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_restitution_get) + +static bool js_FixtureDef_density_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->density, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_density_set) + +static bool js_FixtureDef_density_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->density, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_density_get) + +static bool js_FixtureDef_isSensor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isSensor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_isSensor_set) + +static bool js_FixtureDef_isSensor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isSensor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_isSensor_get) + +static bool js_FixtureDef_filter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->filter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_filter_set) + +static bool js_FixtureDef_filter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->filter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->filter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_filter_get) + +static bool js_delete_b2FixtureDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FixtureDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("shape", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shape), ctx); + } + + + json->getProperty("friction", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->friction), ctx); + } + + + json->getProperty("restitution", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->restitution), ctx); + } + + + json->getProperty("density", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->density), ctx); + } + + + json->getProperty("isSensor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isSensor), ctx); + } + + + json->getProperty("filter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->filter), ctx); + } + + + return ok; +} + + +bool js_register_b2FixtureDef(se::Object* obj) { + auto* cls = se::Class::create("FixtureDef", obj, nullptr, _SE(js_new_b2FixtureDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("shape", _SE(js_FixtureDef_shape_get), _SE(js_FixtureDef_shape_set)); + cls->defineProperty("friction", _SE(js_FixtureDef_friction_get), _SE(js_FixtureDef_friction_set)); + cls->defineProperty("restitution", _SE(js_FixtureDef_restitution_get), _SE(js_FixtureDef_restitution_set)); + cls->defineProperty("density", _SE(js_FixtureDef_density_get), _SE(js_FixtureDef_density_set)); + cls->defineProperty("isSensor", _SE(js_FixtureDef_isSensor_get), _SE(js_FixtureDef_isSensor_set)); + cls->defineProperty("filter", _SE(js_FixtureDef_filter_get), _SE(js_FixtureDef_filter_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FixtureDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FixtureDef_proto = cls->getProto(); + __jsb_b2FixtureDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FixtureProxy_class = nullptr; +se::Object* __jsb_b2FixtureProxy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FixtureProxy) + +static bool js_FixtureProxy_aabb_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->aabb, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_aabb_set) + +static bool js_FixtureProxy_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->aabb, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->aabb, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_aabb_get) + +static bool js_FixtureProxy_fixture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fixture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_fixture_set) + +static bool js_FixtureProxy_fixture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fixture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->fixture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_fixture_get) + +static bool js_FixtureProxy_childIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->childIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_childIndex_set) + +static bool js_FixtureProxy_childIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->childIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->childIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_childIndex_get) + +static bool js_FixtureProxy_proxyId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->proxyId, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_proxyId_set) + +static bool js_FixtureProxy_proxyId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->proxyId, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->proxyId, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_proxyId_get) + +static bool js_new_b2FixtureProxy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2FixtureProxy *result; + result = (b2FixtureProxy *)new b2FixtureProxy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2FixtureProxy, __jsb_b2FixtureProxy_class, js_delete_b2FixtureProxy) + +static bool js_delete_b2FixtureProxy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FixtureProxy) + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureProxy * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("aabb", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->aabb), ctx); + } + + + json->getProperty("fixture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->fixture), ctx); + } + + + json->getProperty("childIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->childIndex), ctx); + } + + + json->getProperty("proxyId", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->proxyId), ctx); + } + + + return ok; +} + + +bool js_register_b2FixtureProxy(se::Object* obj) { + auto* cls = se::Class::create("FixtureProxy", obj, nullptr, _SE(js_new_b2FixtureProxy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("aabb", _SE(js_FixtureProxy_aabb_get), _SE(js_FixtureProxy_aabb_set)); + cls->defineProperty("fixture", _SE(js_FixtureProxy_fixture_get), _SE(js_FixtureProxy_fixture_set)); + cls->defineProperty("childIndex", _SE(js_FixtureProxy_childIndex_get), _SE(js_FixtureProxy_childIndex_set)); + cls->defineProperty("proxyId", _SE(js_FixtureProxy_proxyId_get), _SE(js_FixtureProxy_proxyId_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FixtureProxy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FixtureProxy_proto = cls->getProto(); + __jsb_b2FixtureProxy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Fixture_class = nullptr; +se::Object* __jsb_b2Fixture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Fixture) + +static bool js_Fixture_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Shape::Type result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape::Type)((b2Fixture const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetType) + +static bool js_Fixture_GetShape__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Shape *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape *)(arg1)->GetShape(); + + 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_Fixture_GetShape__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Shape *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape *)((b2Fixture const *)arg1)->GetShape(); + + 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_Fixture_GetShape(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Fixture_GetShape__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Fixture_GetShape__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Fixture_GetShape) + +static bool js_Fixture_SetSensor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSensor(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetSensor) + +static bool js_Fixture_IsSensor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Fixture const *)arg1)->IsSensor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_IsSensor) + +static bool js_Fixture_SetFilterData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Filter *arg2 = 0 ; + b2Filter temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetFilterData((b2Filter const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetFilterData) + +static bool js_Fixture_GetFilterData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Filter *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(s); + if (nullptr == arg1) return true; + result = (b2Filter *) &((b2Fixture const *)arg1)->GetFilterData(); + + 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_Fixture_GetFilterData) + +static bool js_Fixture_Refilter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Refilter(); + + + return true; +} +SE_BIND_FUNC(js_Fixture_Refilter) + +static bool js_Fixture_GetBody__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBody(); + + 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_Fixture_GetBody__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)((b2Fixture const *)arg1)->GetBody(); + + 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_Fixture_GetBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Fixture_GetBody__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Fixture_GetBody__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Fixture_GetBody) + +static bool js_Fixture_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetNext(); + + 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_Fixture_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Fixture const *)arg1)->GetNext(); + + 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_Fixture_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Fixture_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Fixture_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Fixture_GetNext) + +static bool js_Fixture_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((b2Fixture const *)arg1)->GetUserData(); + + 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_Fixture_GetUserData) + +static bool js_Fixture_SetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetUserData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetUserData) + +static bool js_Fixture_TestPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 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(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)((b2Fixture const *)arg1)->TestPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_TestPoint) + +static bool js_Fixture_RayCast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2RayCastOutput *arg2 = (b2RayCastOutput *) NULL ; + b2RayCastInput *arg3 = 0 ; + int32 arg4 ; + b2RayCastInput temp3 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((b2Fixture const *)arg1)->RayCast(arg2,(b2RayCastInput const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_RayCast) + +static bool js_Fixture_GetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Fixture const *)arg1)->GetMassData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetMassData) + +static bool js_Fixture_SetDensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDensity(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetDensity) + +static bool js_Fixture_GetDensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Fixture const *)arg1)->GetDensity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetDensity) + +static bool js_Fixture_GetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Fixture const *)arg1)->GetFriction(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetFriction) + +static bool js_Fixture_SetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFriction(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetFriction) + +static bool js_Fixture_GetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Fixture const *)arg1)->GetRestitution(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetRestitution) + +static bool js_Fixture_SetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetRestitution) + +static bool js_Fixture_GetAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + int32 arg2 ; + b2AABB *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (b2AABB *) &((b2Fixture const *)arg1)->GetAABB(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_Fixture_GetAABB) + +static bool js_Fixture_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->Dump(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_Dump) + +static bool js_delete_b2Fixture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Fixture) + +bool js_register_b2Fixture(se::Object* obj) { + auto* cls = se::Class::create("Fixture", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetType", _SE(js_Fixture_GetType)); + cls->defineFunction("GetShape", _SE(js_Fixture_GetShape)); + cls->defineFunction("SetSensor", _SE(js_Fixture_SetSensor)); + cls->defineFunction("IsSensor", _SE(js_Fixture_IsSensor)); + cls->defineFunction("SetFilterData", _SE(js_Fixture_SetFilterData)); + cls->defineFunction("GetFilterData", _SE(js_Fixture_GetFilterData)); + cls->defineFunction("Refilter", _SE(js_Fixture_Refilter)); + cls->defineFunction("GetBody", _SE(js_Fixture_GetBody)); + cls->defineFunction("GetNext", _SE(js_Fixture_GetNext)); + cls->defineFunction("GetUserData", _SE(js_Fixture_GetUserData)); + cls->defineFunction("SetUserData", _SE(js_Fixture_SetUserData)); + cls->defineFunction("TestPoint", _SE(js_Fixture_TestPoint)); + cls->defineFunction("RayCast", _SE(js_Fixture_RayCast)); + cls->defineFunction("GetMassData", _SE(js_Fixture_GetMassData)); + cls->defineFunction("SetDensity", _SE(js_Fixture_SetDensity)); + cls->defineFunction("GetDensity", _SE(js_Fixture_GetDensity)); + cls->defineFunction("GetFriction", _SE(js_Fixture_GetFriction)); + cls->defineFunction("SetFriction", _SE(js_Fixture_SetFriction)); + cls->defineFunction("GetRestitution", _SE(js_Fixture_GetRestitution)); + cls->defineFunction("SetRestitution", _SE(js_Fixture_SetRestitution)); + cls->defineFunction("GetAABB", _SE(js_Fixture_GetAABB)); + cls->defineFunction("Dump", _SE(js_Fixture_Dump)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Fixture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Fixture_proto = cls->getProto(); + __jsb_b2Fixture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Profile_class = nullptr; +se::Object* __jsb_b2Profile_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Profile) + +static bool js_Profile_step_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->step, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_step_set) + +static bool js_Profile_step_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->step, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_step_get) + +static bool js_Profile_collide_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->collide, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_collide_set) + +static bool js_Profile_collide_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->collide, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_collide_get) + +static bool js_Profile_solve_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solve, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solve_set) + +static bool js_Profile_solve_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solve, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solve_get) + +static bool js_Profile_solveInit_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solveInit, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solveInit_set) + +static bool js_Profile_solveInit_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solveInit, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solveInit_get) + +static bool js_Profile_solveVelocity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solveVelocity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solveVelocity_set) + +static bool js_Profile_solveVelocity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solveVelocity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solveVelocity_get) + +static bool js_Profile_solvePosition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solvePosition, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solvePosition_set) + +static bool js_Profile_solvePosition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solvePosition, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solvePosition_get) + +static bool js_Profile_broadphase_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->broadphase, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_broadphase_set) + +static bool js_Profile_broadphase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->broadphase, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_broadphase_get) + +static bool js_Profile_solveTOI_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solveTOI, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solveTOI_set) + +static bool js_Profile_solveTOI_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solveTOI, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solveTOI_get) + +static bool js_new_b2Profile(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Profile *result; + result = (b2Profile *)new b2Profile(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Profile, __jsb_b2Profile_class, js_delete_b2Profile) + +static bool js_delete_b2Profile(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Profile) + +template<> +bool sevalue_to_native(const se::Value &from, b2Profile * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("step", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->step), ctx); + } + + + json->getProperty("collide", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->collide), ctx); + } + + + json->getProperty("solve", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solve), ctx); + } + + + json->getProperty("solveInit", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solveInit), ctx); + } + + + json->getProperty("solveVelocity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solveVelocity), ctx); + } + + + json->getProperty("solvePosition", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solvePosition), ctx); + } + + + json->getProperty("broadphase", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->broadphase), ctx); + } + + + json->getProperty("solveTOI", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solveTOI), ctx); + } + + + return ok; +} + + +bool js_register_b2Profile(se::Object* obj) { + auto* cls = se::Class::create("Profile", obj, nullptr, _SE(js_new_b2Profile)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("step", _SE(js_Profile_step_get), _SE(js_Profile_step_set)); + cls->defineProperty("collide", _SE(js_Profile_collide_get), _SE(js_Profile_collide_set)); + cls->defineProperty("solve", _SE(js_Profile_solve_get), _SE(js_Profile_solve_set)); + cls->defineProperty("solveInit", _SE(js_Profile_solveInit_get), _SE(js_Profile_solveInit_set)); + cls->defineProperty("solveVelocity", _SE(js_Profile_solveVelocity_get), _SE(js_Profile_solveVelocity_set)); + cls->defineProperty("solvePosition", _SE(js_Profile_solvePosition_get), _SE(js_Profile_solvePosition_set)); + cls->defineProperty("broadphase", _SE(js_Profile_broadphase_get), _SE(js_Profile_broadphase_set)); + cls->defineProperty("solveTOI", _SE(js_Profile_solveTOI_get), _SE(js_Profile_solveTOI_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Profile)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Profile_proto = cls->getProto(); + __jsb_b2Profile_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2TimeStep_class = nullptr; +se::Object* __jsb_b2TimeStep_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2TimeStep) + +static bool js_TimeStep_dt_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dt, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_dt_set) + +static bool js_TimeStep_dt_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dt, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_dt_get) + +static bool js_TimeStep_inv_dt_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inv_dt, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_inv_dt_set) + +static bool js_TimeStep_inv_dt_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inv_dt, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_inv_dt_get) + +static bool js_TimeStep_dtRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dtRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_dtRatio_set) + +static bool js_TimeStep_dtRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dtRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_dtRatio_get) + +static bool js_TimeStep_velocityIterations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->velocityIterations, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_velocityIterations_set) + +static bool js_TimeStep_velocityIterations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->velocityIterations, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->velocityIterations, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_velocityIterations_get) + +static bool js_TimeStep_positionIterations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positionIterations, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_positionIterations_set) + +static bool js_TimeStep_positionIterations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positionIterations, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positionIterations, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_positionIterations_get) + +static bool js_TimeStep_warmStarting_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->warmStarting); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_warmStarting_set) + +static bool js_TimeStep_warmStarting_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->warmStarting, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_warmStarting_get) + +static bool js_new_b2TimeStep(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2TimeStep *result; + result = (b2TimeStep *)new b2TimeStep(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2TimeStep, __jsb_b2TimeStep_class, js_delete_b2TimeStep) + +static bool js_delete_b2TimeStep(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2TimeStep) + +template<> +bool sevalue_to_native(const se::Value &from, b2TimeStep * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("dt", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dt), ctx); + } + + + json->getProperty("inv_dt", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->inv_dt), ctx); + } + + + json->getProperty("dtRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dtRatio), ctx); + } + + + json->getProperty("velocityIterations", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->velocityIterations), ctx); + } + + + json->getProperty("positionIterations", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positionIterations), ctx); + } + + + json->getProperty("warmStarting", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->warmStarting), ctx); + } + + + return ok; +} + + +bool js_register_b2TimeStep(se::Object* obj) { + auto* cls = se::Class::create("TimeStep", obj, nullptr, _SE(js_new_b2TimeStep)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dt", _SE(js_TimeStep_dt_get), _SE(js_TimeStep_dt_set)); + cls->defineProperty("inv_dt", _SE(js_TimeStep_inv_dt_get), _SE(js_TimeStep_inv_dt_set)); + cls->defineProperty("dtRatio", _SE(js_TimeStep_dtRatio_get), _SE(js_TimeStep_dtRatio_set)); + cls->defineProperty("velocityIterations", _SE(js_TimeStep_velocityIterations_get), _SE(js_TimeStep_velocityIterations_set)); + cls->defineProperty("positionIterations", _SE(js_TimeStep_positionIterations_get), _SE(js_TimeStep_positionIterations_set)); + cls->defineProperty("warmStarting", _SE(js_TimeStep_warmStarting_get), _SE(js_TimeStep_warmStarting_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2TimeStep)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2TimeStep_proto = cls->getProto(); + __jsb_b2TimeStep_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Position_class = nullptr; +se::Object* __jsb_b2Position_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Position) + +static bool js_Position_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Position_c_set) + +static bool js_Position_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Position_c_get) + +static bool js_Position_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Position_a_set) + +static bool js_Position_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Position_a_get) + +static bool js_new_b2Position(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Position *result; + result = (b2Position *)new b2Position(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Position, __jsb_b2Position_class, js_delete_b2Position) + +static bool js_delete_b2Position(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Position) + +template<> +bool sevalue_to_native(const se::Value &from, b2Position * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("c", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c), ctx); + } + + + json->getProperty("a", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a), ctx); + } + + + return ok; +} + + +bool js_register_b2Position(se::Object* obj) { + auto* cls = se::Class::create("Position", obj, nullptr, _SE(js_new_b2Position)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("c", _SE(js_Position_c_get), _SE(js_Position_c_set)); + cls->defineProperty("a", _SE(js_Position_a_get), _SE(js_Position_a_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Position)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Position_proto = cls->getProto(); + __jsb_b2Position_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Velocity_class = nullptr; +se::Object* __jsb_b2Velocity_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Velocity) + +static bool js_Velocity_v_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Velocity_v_set) + +static bool js_Velocity_v_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->v, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Velocity_v_get) + +static bool js_Velocity_w_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->w, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Velocity_w_set) + +static bool js_Velocity_w_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->w, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Velocity_w_get) + +static bool js_new_b2Velocity(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Velocity *result; + result = (b2Velocity *)new b2Velocity(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Velocity, __jsb_b2Velocity_class, js_delete_b2Velocity) + +static bool js_delete_b2Velocity(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Velocity) + +template<> +bool sevalue_to_native(const se::Value &from, b2Velocity * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("v", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->v), ctx); + } + + + json->getProperty("w", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->w), ctx); + } + + + return ok; +} + + +bool js_register_b2Velocity(se::Object* obj) { + auto* cls = se::Class::create("Velocity", obj, nullptr, _SE(js_new_b2Velocity)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("v", _SE(js_Velocity_v_get), _SE(js_Velocity_v_set)); + cls->defineProperty("w", _SE(js_Velocity_w_get), _SE(js_Velocity_w_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Velocity)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Velocity_proto = cls->getProto(); + __jsb_b2Velocity_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2SolverData_class = nullptr; +se::Object* __jsb_b2SolverData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2SolverData) + +static bool js_SolverData_step_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->step, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_SolverData_step_set) + +static bool js_SolverData_step_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->step, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->step, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_SolverData_step_get) + +static bool js_SolverData_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_SolverData_positions_set) + +static bool js_SolverData_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_SolverData_positions_get) + +static bool js_SolverData_velocities_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->velocities, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_SolverData_velocities_set) + +static bool js_SolverData_velocities_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->velocities, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->velocities, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_SolverData_velocities_get) + +static bool js_new_b2SolverData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2SolverData *result; + result = (b2SolverData *)new b2SolverData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2SolverData, __jsb_b2SolverData_class, js_delete_b2SolverData) + +static bool js_delete_b2SolverData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2SolverData) + +template<> +bool sevalue_to_native(const se::Value &from, b2SolverData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("step", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->step), ctx); + } + + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("velocities", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->velocities), ctx); + } + + + return ok; +} + + +bool js_register_b2SolverData(se::Object* obj) { + auto* cls = se::Class::create("SolverData", obj, nullptr, _SE(js_new_b2SolverData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("step", _SE(js_SolverData_step_get), _SE(js_SolverData_step_set)); + cls->defineProperty("positions", _SE(js_SolverData_positions_get), _SE(js_SolverData_positions_set)); + cls->defineProperty("velocities", _SE(js_SolverData_velocities_get), _SE(js_SolverData_velocities_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2SolverData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2SolverData_proto = cls->getProto(); + __jsb_b2SolverData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2World_class = nullptr; +se::Object* __jsb_b2World_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2World) + +static bool js_new_b2World(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + b2Vec2 *arg1 = 0 ; + b2Vec2 temp1 ; + b2World *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (b2World *)new b2World((b2Vec2 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2World, __jsb_b2World_class, js_delete_b2World) + +static bool js_delete_b2World(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2World) + +static bool js_World_SetDestructionListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2DestructionListener *arg2 = (b2DestructionListener *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDestructionListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetDestructionListener) + +static bool js_World_SetContactFilter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2ContactFilter *arg2 = (b2ContactFilter *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetContactFilter(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetContactFilter) + +static bool js_World_CreateBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2BodyDef *arg2 = (b2BodyDef *) NULL ; + b2Body *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Body *)(arg1)->CreateBody((b2BodyDef 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_World_CreateBody) + +static bool js_World_DestroyBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->DestroyBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_DestroyBody) + +static bool js_World_CreateJoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2JointDef *arg2 = (b2JointDef *) NULL ; + b2Joint *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Joint *)(arg1)->CreateJoint((b2JointDef 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_World_CreateJoint) + +static bool js_World_DestroyJoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Joint *arg2 = (b2Joint *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->DestroyJoint(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_DestroyJoint) + +static bool js_World_Step(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + float arg2 ; + int32 arg3 ; + int32 arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Step(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_World_Step) + +static bool js_World_ClearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ClearForces(); + + + return true; +} +SE_BIND_FUNC(js_World_ClearForces) + +static bool js_World_DrawDebugData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->DebugDraw(); + + + return true; +} +SE_BIND_FUNC(js_World_DrawDebugData) + +static bool js_World_GetBodyList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBodyList(); + + 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_World_GetBodyList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)((b2World const *)arg1)->GetBodyList(); + + 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_World_GetBodyList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_World_GetBodyList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_World_GetBodyList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_World_GetBodyList) + +static bool js_World_GetJointList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetJointList(); + + 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_World_GetJointList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)((b2World const *)arg1)->GetJointList(); + + 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_World_GetJointList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_World_GetJointList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_World_GetJointList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_World_GetJointList) + +static bool js_World_GetContactList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)(arg1)->GetContactList(); + + 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_World_GetContactList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)((b2World const *)arg1)->GetContactList(); + + 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_World_GetContactList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_World_GetContactList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_World_GetContactList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_World_GetContactList) + +static bool js_World_SetAllowSleeping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAllowSleeping(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetAllowSleeping) + +static bool js_World_GetAllowSleeping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetAllowSleeping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetAllowSleeping) + +static bool js_World_SetWarmStarting(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetWarmStarting(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetWarmStarting) + +static bool js_World_GetWarmStarting(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetWarmStarting(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetWarmStarting) + +static bool js_World_SetContinuousPhysics(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetContinuousPhysics(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetContinuousPhysics) + +static bool js_World_GetContinuousPhysics(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetContinuousPhysics(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetContinuousPhysics) + +static bool js_World_SetSubStepping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSubStepping(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetSubStepping) + +static bool js_World_GetSubStepping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetSubStepping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetSubStepping) + +static bool js_World_GetProxyCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetProxyCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetProxyCount) + +static bool js_World_GetBodyCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetBodyCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetBodyCount) + +static bool js_World_GetJointCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetJointCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetJointCount) + +static bool js_World_GetContactCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetContactCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetContactCount) + +static bool js_World_GetTreeHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetTreeHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetTreeHeight) + +static bool js_World_GetTreeBalance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetTreeBalance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetTreeBalance) + +static bool js_World_GetTreeQuality(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2World const *)arg1)->GetTreeQuality(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetTreeQuality) + +static bool js_World_SetGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetGravity((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetGravity) + +static bool js_World_GetGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetGravity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetGravity) + +static bool js_World_IsLocked(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->IsLocked(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_IsLocked) + +static bool js_World_SetAutoClearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAutoClearForces(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetAutoClearForces) + +static bool js_World_GetAutoClearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetAutoClearForces(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetAutoClearForces) + +static bool js_World_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_World_ShiftOrigin) + +static bool js_World_GetContactManager(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2ContactManager *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(s); + if (nullptr == arg1) return true; + result = (b2ContactManager *) &((b2World const *)arg1)->GetContactManager(); + + 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_World_GetContactManager) + +static bool js_World_GetProfile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Profile *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(s); + if (nullptr == arg1) return true; + result = (b2Profile *) &((b2World const *)arg1)->GetProfile(); + + 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_World_GetProfile) + +static bool js_World_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Dump(); + + + return true; +} +SE_BIND_FUNC(js_World_Dump) + +bool js_register_b2World(se::Object* obj) { + auto* cls = se::Class::create("World", obj, nullptr, _SE(js_new_b2World)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SetDestructionListener", _SE(js_World_SetDestructionListener)); + cls->defineFunction("SetContactFilter", _SE(js_World_SetContactFilter)); + cls->defineFunction("CreateBody", _SE(js_World_CreateBody)); + cls->defineFunction("DestroyBody", _SE(js_World_DestroyBody)); + cls->defineFunction("CreateJoint", _SE(js_World_CreateJoint)); + cls->defineFunction("DestroyJoint", _SE(js_World_DestroyJoint)); + cls->defineFunction("Step", _SE(js_World_Step)); + cls->defineFunction("ClearForces", _SE(js_World_ClearForces)); + cls->defineFunction("DrawDebugData", _SE(js_World_DrawDebugData)); + cls->defineFunction("GetBodyList", _SE(js_World_GetBodyList)); + cls->defineFunction("GetJointList", _SE(js_World_GetJointList)); + cls->defineFunction("GetContactList", _SE(js_World_GetContactList)); + cls->defineFunction("SetAllowSleeping", _SE(js_World_SetAllowSleeping)); + cls->defineFunction("GetAllowSleeping", _SE(js_World_GetAllowSleeping)); + cls->defineFunction("SetWarmStarting", _SE(js_World_SetWarmStarting)); + cls->defineFunction("GetWarmStarting", _SE(js_World_GetWarmStarting)); + cls->defineFunction("SetContinuousPhysics", _SE(js_World_SetContinuousPhysics)); + cls->defineFunction("GetContinuousPhysics", _SE(js_World_GetContinuousPhysics)); + cls->defineFunction("SetSubStepping", _SE(js_World_SetSubStepping)); + cls->defineFunction("GetSubStepping", _SE(js_World_GetSubStepping)); + cls->defineFunction("GetProxyCount", _SE(js_World_GetProxyCount)); + cls->defineFunction("GetBodyCount", _SE(js_World_GetBodyCount)); + cls->defineFunction("GetJointCount", _SE(js_World_GetJointCount)); + cls->defineFunction("GetContactCount", _SE(js_World_GetContactCount)); + cls->defineFunction("GetTreeHeight", _SE(js_World_GetTreeHeight)); + cls->defineFunction("GetTreeBalance", _SE(js_World_GetTreeBalance)); + cls->defineFunction("GetTreeQuality", _SE(js_World_GetTreeQuality)); + cls->defineFunction("SetGravity", _SE(js_World_SetGravity)); + cls->defineFunction("GetGravity", _SE(js_World_GetGravity)); + cls->defineFunction("IsLocked", _SE(js_World_IsLocked)); + cls->defineFunction("SetAutoClearForces", _SE(js_World_SetAutoClearForces)); + cls->defineFunction("GetAutoClearForces", _SE(js_World_GetAutoClearForces)); + cls->defineFunction("ShiftOrigin", _SE(js_World_ShiftOrigin)); + cls->defineFunction("GetContactManager", _SE(js_World_GetContactManager)); + cls->defineFunction("GetProfile", _SE(js_World_GetProfile)); + cls->defineFunction("Dump", _SE(js_World_Dump)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2World)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2World_proto = cls->getProto(); + __jsb_b2World_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DestructionListener_class = nullptr; +se::Object* __jsb_b2DestructionListener_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DestructionListener) + +static bool js_delete_b2DestructionListener(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DestructionListener) + +static bool js_DestructionListener_SayGoodbye__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2DestructionListener *arg1 = (b2DestructionListener *) NULL ; + b2Joint *arg2 = (b2Joint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SayGoodbye(arg2); + + + return true; +} + +static bool js_DestructionListener_SayGoodbye__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2DestructionListener *arg1 = (b2DestructionListener *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SayGoodbye(arg2); + + + return true; +} + +static bool js_DestructionListener_SayGoodbye(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_DestructionListener_SayGoodbye__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_DestructionListener_SayGoodbye__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_DestructionListener_SayGoodbye) + +bool js_register_b2DestructionListener(se::Object* obj) { + auto* cls = se::Class::create("DestructionListener", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SayGoodbye", _SE(js_DestructionListener_SayGoodbye)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DestructionListener)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DestructionListener_proto = cls->getProto(); + __jsb_b2DestructionListener_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactFilter_class = nullptr; +se::Object* __jsb_b2ContactFilter_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactFilter) + +static bool js_delete_b2ContactFilter(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactFilter) + +static bool js_ContactFilter_ShouldCollide(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFilter *arg1 = (b2ContactFilter *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + b2Fixture *arg3 = (b2Fixture *) NULL ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->ShouldCollide(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_ContactFilter_ShouldCollide) + +static bool js_new_b2ContactFilter(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactFilter *result; + result = (b2ContactFilter *)new b2ContactFilter(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactFilter, __jsb_b2ContactFilter_class, js_delete_b2ContactFilter) + +bool js_register_b2ContactFilter(se::Object* obj) { + auto* cls = se::Class::create("ContactFilter", obj, nullptr, _SE(js_new_b2ContactFilter)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("ShouldCollide", _SE(js_ContactFilter_ShouldCollide)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactFilter)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactFilter_proto = cls->getProto(); + __jsb_b2ContactFilter_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactImpulse_class = nullptr; +se::Object* __jsb_b2ContactImpulse_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactImpulse) + +static bool js_ContactImpulse_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactImpulse *arg1 = (b2ContactImpulse *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactImpulse_count_set) + +static bool js_ContactImpulse_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactImpulse *arg1 = (b2ContactImpulse *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->count, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactImpulse_count_get) + +static bool js_new_b2ContactImpulse(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactImpulse *result; + result = (b2ContactImpulse *)new b2ContactImpulse(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactImpulse, __jsb_b2ContactImpulse_class, js_delete_b2ContactImpulse) + +static bool js_delete_b2ContactImpulse(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactImpulse) + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactImpulse * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + return ok; +} + + +bool js_register_b2ContactImpulse(se::Object* obj) { + auto* cls = se::Class::create("ContactImpulse", obj, nullptr, _SE(js_new_b2ContactImpulse)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("count", _SE(js_ContactImpulse_count_get), _SE(js_ContactImpulse_count_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactImpulse)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactImpulse_proto = cls->getProto(); + __jsb_b2ContactImpulse_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RopeJointDef_class = nullptr; +se::Object* __jsb_b2RopeJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RopeJointDef) + +static bool js_new_b2RopeJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RopeJointDef *result; + result = (b2RopeJointDef *)new b2RopeJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RopeJointDef, __jsb_b2RopeJointDef_class, js_delete_b2RopeJointDef) + +static bool js_RopeJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RopeJointDef_localAnchorA_set) + +static bool js_RopeJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RopeJointDef_localAnchorA_get) + +static bool js_RopeJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RopeJointDef_localAnchorB_set) + +static bool js_RopeJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RopeJointDef_localAnchorB_get) + +static bool js_RopeJointDef_maxLength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxLength, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RopeJointDef_maxLength_set) + +static bool js_RopeJointDef_maxLength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxLength, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RopeJointDef_maxLength_get) + +static bool js_delete_b2RopeJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RopeJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2RopeJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("maxLength", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxLength), ctx); + } + + + return ok; +} + + +bool js_register_b2RopeJointDef(se::Object* obj) { + auto* cls = se::Class::create("RopeJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2RopeJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_RopeJointDef_localAnchorA_get), _SE(js_RopeJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_RopeJointDef_localAnchorB_get), _SE(js_RopeJointDef_localAnchorB_set)); + cls->defineProperty("maxLength", _SE(js_RopeJointDef_maxLength_get), _SE(js_RopeJointDef_maxLength_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RopeJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RopeJointDef_proto = cls->getProto(); + __jsb_b2RopeJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RopeJoint_class = nullptr; +se::Object* __jsb_b2RopeJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RopeJoint) + +static bool js_RopeJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RopeJoint const *)arg1)->GetLocalAnchorA(); + + 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_RopeJoint_GetLocalAnchorA) + +static bool js_RopeJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RopeJoint const *)arg1)->GetLocalAnchorB(); + + 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_RopeJoint_GetLocalAnchorB) + +static bool js_RopeJoint_SetMaxLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxLength(arg2); + + + return true; +} +SE_BIND_FUNC(js_RopeJoint_SetMaxLength) + +static bool js_RopeJoint_GetMaxLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RopeJoint const *)arg1)->GetMaxLength(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RopeJoint_GetMaxLength) + +static bool js_RopeJoint_GetLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RopeJoint const *)arg1)->GetLength(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RopeJoint_GetLength) + +static bool js_delete_b2RopeJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RopeJoint) + +bool js_register_b2RopeJoint(se::Object* obj) { + auto* cls = se::Class::create("RopeJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_RopeJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_RopeJoint_GetLocalAnchorB)); + cls->defineFunction("SetMaxLength", _SE(js_RopeJoint_SetMaxLength)); + cls->defineFunction("GetMaxLength", _SE(js_RopeJoint_GetMaxLength)); + cls->defineFunction("GetLength", _SE(js_RopeJoint_GetLength)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RopeJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RopeJoint_proto = cls->getProto(); + __jsb_b2RopeJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FrictionJointDef_class = nullptr; +se::Object* __jsb_b2FrictionJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FrictionJointDef) + +static bool js_new_b2FrictionJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2FrictionJointDef *result; + result = (b2FrictionJointDef *)new b2FrictionJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2FrictionJointDef, __jsb_b2FrictionJointDef_class, js_delete_b2FrictionJointDef) + +static bool js_FrictionJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_FrictionJointDef_Initialize) + +static bool js_FrictionJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_localAnchorA_set) + +static bool js_FrictionJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_localAnchorA_get) + +static bool js_FrictionJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_localAnchorB_set) + +static bool js_FrictionJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_localAnchorB_get) + +static bool js_FrictionJointDef_maxForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_maxForce_set) + +static bool js_FrictionJointDef_maxForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_maxForce_get) + +static bool js_FrictionJointDef_maxTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_maxTorque_set) + +static bool js_FrictionJointDef_maxTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_maxTorque_get) + +static bool js_delete_b2FrictionJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FrictionJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2FrictionJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("maxForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxForce), ctx); + } + + + json->getProperty("maxTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTorque), ctx); + } + + + return ok; +} + + +bool js_register_b2FrictionJointDef(se::Object* obj) { + auto* cls = se::Class::create("FrictionJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2FrictionJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_FrictionJointDef_localAnchorA_get), _SE(js_FrictionJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_FrictionJointDef_localAnchorB_get), _SE(js_FrictionJointDef_localAnchorB_set)); + cls->defineProperty("maxForce", _SE(js_FrictionJointDef_maxForce_get), _SE(js_FrictionJointDef_maxForce_set)); + cls->defineProperty("maxTorque", _SE(js_FrictionJointDef_maxTorque_get), _SE(js_FrictionJointDef_maxTorque_set)); + + cls->defineFunction("Initialize", _SE(js_FrictionJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FrictionJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FrictionJointDef_proto = cls->getProto(); + __jsb_b2FrictionJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FrictionJoint_class = nullptr; +se::Object* __jsb_b2FrictionJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FrictionJoint) + +static bool js_FrictionJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2FrictionJoint const *)arg1)->GetLocalAnchorA(); + + 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_FrictionJoint_GetLocalAnchorA) + +static bool js_FrictionJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2FrictionJoint const *)arg1)->GetLocalAnchorB(); + + 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_FrictionJoint_GetLocalAnchorB) + +static bool js_FrictionJoint_SetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_SetMaxForce) + +static bool js_FrictionJoint_GetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2FrictionJoint const *)arg1)->GetMaxForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_GetMaxForce) + +static bool js_FrictionJoint_SetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_SetMaxTorque) + +static bool js_FrictionJoint_GetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2FrictionJoint const *)arg1)->GetMaxTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_GetMaxTorque) + +static bool js_delete_b2FrictionJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FrictionJoint) + +bool js_register_b2FrictionJoint(se::Object* obj) { + auto* cls = se::Class::create("FrictionJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_FrictionJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_FrictionJoint_GetLocalAnchorB)); + cls->defineFunction("SetMaxForce", _SE(js_FrictionJoint_SetMaxForce)); + cls->defineFunction("GetMaxForce", _SE(js_FrictionJoint_GetMaxForce)); + cls->defineFunction("SetMaxTorque", _SE(js_FrictionJoint_SetMaxTorque)); + cls->defineFunction("GetMaxTorque", _SE(js_FrictionJoint_GetMaxTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FrictionJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FrictionJoint_proto = cls->getProto(); + __jsb_b2FrictionJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DistanceJointDef_class = nullptr; +se::Object* __jsb_b2DistanceJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DistanceJointDef) + +static bool js_new_b2DistanceJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2DistanceJointDef *result; + result = (b2DistanceJointDef *)new b2DistanceJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2DistanceJointDef, __jsb_b2DistanceJointDef_class, js_delete_b2DistanceJointDef) + +static bool js_DistanceJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_DistanceJointDef_Initialize) + +static bool js_DistanceJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_localAnchorA_set) + +static bool js_DistanceJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_localAnchorA_get) + +static bool js_DistanceJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_localAnchorB_set) + +static bool js_DistanceJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_localAnchorB_get) + +static bool js_DistanceJointDef_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->length, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_length_set) + +static bool js_DistanceJointDef_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->length, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_length_get) + +static bool js_DistanceJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_frequencyHz_set) + +static bool js_DistanceJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_frequencyHz_get) + +static bool js_DistanceJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_dampingRatio_set) + +static bool js_DistanceJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_dampingRatio_get) + +static bool js_delete_b2DistanceJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DistanceJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2DistanceJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("length", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->length), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2DistanceJointDef(se::Object* obj) { + auto* cls = se::Class::create("DistanceJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2DistanceJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_DistanceJointDef_localAnchorA_get), _SE(js_DistanceJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_DistanceJointDef_localAnchorB_get), _SE(js_DistanceJointDef_localAnchorB_set)); + cls->defineProperty("length", _SE(js_DistanceJointDef_length_get), _SE(js_DistanceJointDef_length_set)); + cls->defineProperty("frequencyHz", _SE(js_DistanceJointDef_frequencyHz_get), _SE(js_DistanceJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_DistanceJointDef_dampingRatio_get), _SE(js_DistanceJointDef_dampingRatio_set)); + + cls->defineFunction("Initialize", _SE(js_DistanceJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DistanceJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DistanceJointDef_proto = cls->getProto(); + __jsb_b2DistanceJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DistanceJoint_class = nullptr; +se::Object* __jsb_b2DistanceJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DistanceJoint) + +static bool js_DistanceJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2DistanceJoint const *)arg1)->GetLocalAnchorA(); + + 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_DistanceJoint_GetLocalAnchorA) + +static bool js_DistanceJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2DistanceJoint const *)arg1)->GetLocalAnchorB(); + + 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_DistanceJoint_GetLocalAnchorB) + +static bool js_DistanceJoint_SetLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetLength(arg2); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_SetLength) + +static bool js_DistanceJoint_GetLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DistanceJoint const *)arg1)->GetLength(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_GetLength) + +static bool js_DistanceJoint_SetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFrequency(arg2); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_SetFrequency) + +static bool js_DistanceJoint_GetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DistanceJoint const *)arg1)->GetFrequency(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_GetFrequency) + +static bool js_DistanceJoint_SetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_SetDampingRatio) + +static bool js_DistanceJoint_GetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DistanceJoint const *)arg1)->GetDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_GetDampingRatio) + +static bool js_delete_b2DistanceJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DistanceJoint) + +bool js_register_b2DistanceJoint(se::Object* obj) { + auto* cls = se::Class::create("DistanceJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_DistanceJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_DistanceJoint_GetLocalAnchorB)); + cls->defineFunction("SetLength", _SE(js_DistanceJoint_SetLength)); + cls->defineFunction("GetLength", _SE(js_DistanceJoint_GetLength)); + cls->defineFunction("SetFrequency", _SE(js_DistanceJoint_SetFrequency)); + cls->defineFunction("GetFrequency", _SE(js_DistanceJoint_GetFrequency)); + cls->defineFunction("SetDampingRatio", _SE(js_DistanceJoint_SetDampingRatio)); + cls->defineFunction("GetDampingRatio", _SE(js_DistanceJoint_GetDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DistanceJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DistanceJoint_proto = cls->getProto(); + __jsb_b2DistanceJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2GearJointDef_class = nullptr; +se::Object* __jsb_b2GearJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2GearJointDef) + +static bool js_new_b2GearJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2GearJointDef *result; + result = (b2GearJointDef *)new b2GearJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2GearJointDef, __jsb_b2GearJointDef_class, js_delete_b2GearJointDef) + +static bool js_GearJointDef_joint1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->joint1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_GearJointDef_joint1_set) + +static bool js_GearJointDef_joint1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->joint1, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->joint1, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_GearJointDef_joint1_get) + +static bool js_GearJointDef_joint2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->joint2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_GearJointDef_joint2_set) + +static bool js_GearJointDef_joint2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->joint2, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->joint2, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_GearJointDef_joint2_get) + +static bool js_GearJointDef_ratio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ratio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_GearJointDef_ratio_set) + +static bool js_GearJointDef_ratio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ratio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_GearJointDef_ratio_get) + +static bool js_delete_b2GearJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2GearJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2GearJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("joint1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->joint1), ctx); + } + + + json->getProperty("joint2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->joint2), ctx); + } + + + json->getProperty("ratio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ratio), ctx); + } + + + return ok; +} + + +bool js_register_b2GearJointDef(se::Object* obj) { + auto* cls = se::Class::create("GearJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2GearJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("joint1", _SE(js_GearJointDef_joint1_get), _SE(js_GearJointDef_joint1_set)); + cls->defineProperty("joint2", _SE(js_GearJointDef_joint2_get), _SE(js_GearJointDef_joint2_set)); + cls->defineProperty("ratio", _SE(js_GearJointDef_ratio_get), _SE(js_GearJointDef_ratio_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2GearJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2GearJointDef_proto = cls->getProto(); + __jsb_b2GearJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2GearJoint_class = nullptr; +se::Object* __jsb_b2GearJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2GearJoint) + +static bool js_GearJoint_GetJoint1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + b2Joint *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(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetJoint1(); + + 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_GearJoint_GetJoint1) + +static bool js_GearJoint_GetJoint2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + b2Joint *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(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetJoint2(); + + 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_GearJoint_GetJoint2) + +static bool js_GearJoint_SetRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_GearJoint_SetRatio) + +static bool js_GearJoint_GetRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2GearJoint const *)arg1)->GetRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_GearJoint_GetRatio) + +static bool js_delete_b2GearJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2GearJoint) + +bool js_register_b2GearJoint(se::Object* obj) { + auto* cls = se::Class::create("GearJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetJoint1", _SE(js_GearJoint_GetJoint1)); + cls->defineFunction("GetJoint2", _SE(js_GearJoint_GetJoint2)); + cls->defineFunction("SetRatio", _SE(js_GearJoint_SetRatio)); + cls->defineFunction("GetRatio", _SE(js_GearJoint_GetRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2GearJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2GearJoint_proto = cls->getProto(); + __jsb_b2GearJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MotorJointDef_class = nullptr; +se::Object* __jsb_b2MotorJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MotorJointDef) + +static bool js_new_b2MotorJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2MotorJointDef *result; + result = (b2MotorJointDef *)new b2MotorJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2MotorJointDef, __jsb_b2MotorJointDef_class, js_delete_b2MotorJointDef) + +static bool js_MotorJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Initialize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_MotorJointDef_Initialize) + +static bool js_MotorJointDef_linearOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linearOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_linearOffset_set) + +static bool js_MotorJointDef_linearOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linearOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linearOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_linearOffset_get) + +static bool js_MotorJointDef_angularOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_angularOffset_set) + +static bool js_MotorJointDef_angularOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_angularOffset_get) + +static bool js_MotorJointDef_maxForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_maxForce_set) + +static bool js_MotorJointDef_maxForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_maxForce_get) + +static bool js_MotorJointDef_maxTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_maxTorque_set) + +static bool js_MotorJointDef_maxTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_maxTorque_get) + +static bool js_MotorJointDef_correctionFactor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->correctionFactor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_correctionFactor_set) + +static bool js_MotorJointDef_correctionFactor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->correctionFactor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_correctionFactor_get) + +static bool js_delete_b2MotorJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MotorJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2MotorJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("linearOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linearOffset), ctx); + } + + + json->getProperty("angularOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularOffset), ctx); + } + + + json->getProperty("maxForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxForce), ctx); + } + + + json->getProperty("maxTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTorque), ctx); + } + + + json->getProperty("correctionFactor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->correctionFactor), ctx); + } + + + return ok; +} + + +bool js_register_b2MotorJointDef(se::Object* obj) { + auto* cls = se::Class::create("MotorJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2MotorJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("linearOffset", _SE(js_MotorJointDef_linearOffset_get), _SE(js_MotorJointDef_linearOffset_set)); + cls->defineProperty("angularOffset", _SE(js_MotorJointDef_angularOffset_get), _SE(js_MotorJointDef_angularOffset_set)); + cls->defineProperty("maxForce", _SE(js_MotorJointDef_maxForce_get), _SE(js_MotorJointDef_maxForce_set)); + cls->defineProperty("maxTorque", _SE(js_MotorJointDef_maxTorque_get), _SE(js_MotorJointDef_maxTorque_set)); + cls->defineProperty("correctionFactor", _SE(js_MotorJointDef_correctionFactor_get), _SE(js_MotorJointDef_correctionFactor_set)); + + cls->defineFunction("Initialize", _SE(js_MotorJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MotorJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MotorJointDef_proto = cls->getProto(); + __jsb_b2MotorJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MotorJoint_class = nullptr; +se::Object* __jsb_b2MotorJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MotorJoint) + +static bool js_MotorJoint_SetLinearOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLinearOffset((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetLinearOffset) + +static bool js_MotorJoint_GetLinearOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2MotorJoint const *)arg1)->GetLinearOffset(); + + 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_MotorJoint_GetLinearOffset) + +static bool js_MotorJoint_SetAngularOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAngularOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetAngularOffset) + +static bool js_MotorJoint_GetAngularOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetAngularOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetAngularOffset) + +static bool js_MotorJoint_SetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetMaxForce) + +static bool js_MotorJoint_GetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetMaxForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetMaxForce) + +static bool js_MotorJoint_SetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetMaxTorque) + +static bool js_MotorJoint_GetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetMaxTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetMaxTorque) + +static bool js_MotorJoint_SetCorrectionFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetCorrectionFactor(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetCorrectionFactor) + +static bool js_MotorJoint_GetCorrectionFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetCorrectionFactor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetCorrectionFactor) + +static bool js_delete_b2MotorJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MotorJoint) + +bool js_register_b2MotorJoint(se::Object* obj) { + auto* cls = se::Class::create("MotorJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SetLinearOffset", _SE(js_MotorJoint_SetLinearOffset)); + cls->defineFunction("GetLinearOffset", _SE(js_MotorJoint_GetLinearOffset)); + cls->defineFunction("SetAngularOffset", _SE(js_MotorJoint_SetAngularOffset)); + cls->defineFunction("GetAngularOffset", _SE(js_MotorJoint_GetAngularOffset)); + cls->defineFunction("SetMaxForce", _SE(js_MotorJoint_SetMaxForce)); + cls->defineFunction("GetMaxForce", _SE(js_MotorJoint_GetMaxForce)); + cls->defineFunction("SetMaxTorque", _SE(js_MotorJoint_SetMaxTorque)); + cls->defineFunction("GetMaxTorque", _SE(js_MotorJoint_GetMaxTorque)); + cls->defineFunction("SetCorrectionFactor", _SE(js_MotorJoint_SetCorrectionFactor)); + cls->defineFunction("GetCorrectionFactor", _SE(js_MotorJoint_GetCorrectionFactor)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MotorJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MotorJoint_proto = cls->getProto(); + __jsb_b2MotorJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MouseJointDef_class = nullptr; +se::Object* __jsb_b2MouseJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MouseJointDef) + +static bool js_new_b2MouseJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2MouseJointDef *result; + result = (b2MouseJointDef *)new b2MouseJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2MouseJointDef, __jsb_b2MouseJointDef_class, js_delete_b2MouseJointDef) + +static bool js_MouseJointDef_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->target, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_target_set) + +static bool js_MouseJointDef_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->target, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->target, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_target_get) + +static bool js_MouseJointDef_maxForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_maxForce_set) + +static bool js_MouseJointDef_maxForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_maxForce_get) + +static bool js_MouseJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_frequencyHz_set) + +static bool js_MouseJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_frequencyHz_get) + +static bool js_MouseJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_dampingRatio_set) + +static bool js_MouseJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_dampingRatio_get) + +static bool js_delete_b2MouseJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MouseJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2MouseJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("target", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->target), ctx); + } + + + json->getProperty("maxForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxForce), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2MouseJointDef(se::Object* obj) { + auto* cls = se::Class::create("MouseJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2MouseJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("target", _SE(js_MouseJointDef_target_get), _SE(js_MouseJointDef_target_set)); + cls->defineProperty("maxForce", _SE(js_MouseJointDef_maxForce_get), _SE(js_MouseJointDef_maxForce_set)); + cls->defineProperty("frequencyHz", _SE(js_MouseJointDef_frequencyHz_get), _SE(js_MouseJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_MouseJointDef_dampingRatio_get), _SE(js_MouseJointDef_dampingRatio_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MouseJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MouseJointDef_proto = cls->getProto(); + __jsb_b2MouseJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MouseJoint_class = nullptr; +se::Object* __jsb_b2MouseJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MouseJoint) + +static bool js_MouseJoint_SetTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetTarget((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetTarget) + +static bool js_MouseJoint_GetTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2MouseJoint const *)arg1)->GetTarget(); + + 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_MouseJoint_GetTarget) + +static bool js_MouseJoint_SetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetMaxForce) + +static bool js_MouseJoint_GetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MouseJoint const *)arg1)->GetMaxForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_GetMaxForce) + +static bool js_MouseJoint_SetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFrequency(arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetFrequency) + +static bool js_MouseJoint_GetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MouseJoint const *)arg1)->GetFrequency(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_GetFrequency) + +static bool js_MouseJoint_SetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetDampingRatio) + +static bool js_MouseJoint_GetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MouseJoint const *)arg1)->GetDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_GetDampingRatio) + +static bool js_delete_b2MouseJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MouseJoint) + +bool js_register_b2MouseJoint(se::Object* obj) { + auto* cls = se::Class::create("MouseJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SetTarget", _SE(js_MouseJoint_SetTarget)); + cls->defineFunction("GetTarget", _SE(js_MouseJoint_GetTarget)); + cls->defineFunction("SetMaxForce", _SE(js_MouseJoint_SetMaxForce)); + cls->defineFunction("GetMaxForce", _SE(js_MouseJoint_GetMaxForce)); + cls->defineFunction("SetFrequency", _SE(js_MouseJoint_SetFrequency)); + cls->defineFunction("GetFrequency", _SE(js_MouseJoint_GetFrequency)); + cls->defineFunction("SetDampingRatio", _SE(js_MouseJoint_SetDampingRatio)); + cls->defineFunction("GetDampingRatio", _SE(js_MouseJoint_GetDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MouseJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MouseJoint_proto = cls->getProto(); + __jsb_b2MouseJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PrismaticJointDef_class = nullptr; +se::Object* __jsb_b2PrismaticJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PrismaticJointDef) + +static bool js_new_b2PrismaticJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2PrismaticJointDef *result; + result = (b2PrismaticJointDef *)new b2PrismaticJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2PrismaticJointDef, __jsb_b2PrismaticJointDef_class, js_delete_b2PrismaticJointDef) + +static bool js_PrismaticJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJointDef_Initialize) + +static bool js_PrismaticJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_localAnchorA_set) + +static bool js_PrismaticJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_localAnchorA_get) + +static bool js_PrismaticJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_localAnchorB_set) + +static bool js_PrismaticJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_localAnchorB_get) + +static bool js_PrismaticJointDef_localAxisA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAxisA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_localAxisA_set) + +static bool js_PrismaticJointDef_localAxisA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAxisA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAxisA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_localAxisA_get) + +static bool js_PrismaticJointDef_referenceAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->referenceAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_referenceAngle_set) + +static bool js_PrismaticJointDef_referenceAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->referenceAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_referenceAngle_get) + +static bool js_PrismaticJointDef_enableLimit_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableLimit); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_enableLimit_set) + +static bool js_PrismaticJointDef_enableLimit_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableLimit, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_enableLimit_get) + +static bool js_PrismaticJointDef_lowerTranslation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lowerTranslation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_lowerTranslation_set) + +static bool js_PrismaticJointDef_lowerTranslation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lowerTranslation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_lowerTranslation_get) + +static bool js_PrismaticJointDef_upperTranslation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->upperTranslation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_upperTranslation_set) + +static bool js_PrismaticJointDef_upperTranslation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->upperTranslation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_upperTranslation_get) + +static bool js_PrismaticJointDef_enableMotor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableMotor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_enableMotor_set) + +static bool js_PrismaticJointDef_enableMotor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableMotor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_enableMotor_get) + +static bool js_PrismaticJointDef_maxMotorForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxMotorForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_maxMotorForce_set) + +static bool js_PrismaticJointDef_maxMotorForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxMotorForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_maxMotorForce_get) + +static bool js_PrismaticJointDef_motorSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->motorSpeed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_motorSpeed_set) + +static bool js_PrismaticJointDef_motorSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->motorSpeed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_motorSpeed_get) + +static bool js_delete_b2PrismaticJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PrismaticJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2PrismaticJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("localAxisA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAxisA), ctx); + } + + + json->getProperty("referenceAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->referenceAngle), ctx); + } + + + json->getProperty("enableLimit", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableLimit), ctx); + } + + + json->getProperty("lowerTranslation", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lowerTranslation), ctx); + } + + + json->getProperty("upperTranslation", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->upperTranslation), ctx); + } + + + json->getProperty("enableMotor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableMotor), ctx); + } + + + json->getProperty("maxMotorForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxMotorForce), ctx); + } + + + json->getProperty("motorSpeed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->motorSpeed), ctx); + } + + + return ok; +} + + +bool js_register_b2PrismaticJointDef(se::Object* obj) { + auto* cls = se::Class::create("PrismaticJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2PrismaticJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_PrismaticJointDef_localAnchorA_get), _SE(js_PrismaticJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_PrismaticJointDef_localAnchorB_get), _SE(js_PrismaticJointDef_localAnchorB_set)); + cls->defineProperty("localAxisA", _SE(js_PrismaticJointDef_localAxisA_get), _SE(js_PrismaticJointDef_localAxisA_set)); + cls->defineProperty("referenceAngle", _SE(js_PrismaticJointDef_referenceAngle_get), _SE(js_PrismaticJointDef_referenceAngle_set)); + cls->defineProperty("enableLimit", _SE(js_PrismaticJointDef_enableLimit_get), _SE(js_PrismaticJointDef_enableLimit_set)); + cls->defineProperty("lowerTranslation", _SE(js_PrismaticJointDef_lowerTranslation_get), _SE(js_PrismaticJointDef_lowerTranslation_set)); + cls->defineProperty("upperTranslation", _SE(js_PrismaticJointDef_upperTranslation_get), _SE(js_PrismaticJointDef_upperTranslation_set)); + cls->defineProperty("enableMotor", _SE(js_PrismaticJointDef_enableMotor_get), _SE(js_PrismaticJointDef_enableMotor_set)); + cls->defineProperty("maxMotorForce", _SE(js_PrismaticJointDef_maxMotorForce_get), _SE(js_PrismaticJointDef_maxMotorForce_set)); + cls->defineProperty("motorSpeed", _SE(js_PrismaticJointDef_motorSpeed_get), _SE(js_PrismaticJointDef_motorSpeed_set)); + + cls->defineFunction("Initialize", _SE(js_PrismaticJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PrismaticJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PrismaticJointDef_proto = cls->getProto(); + __jsb_b2PrismaticJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PrismaticJoint_class = nullptr; +se::Object* __jsb_b2PrismaticJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PrismaticJoint) + +static bool js_PrismaticJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2PrismaticJoint const *)arg1)->GetLocalAnchorA(); + + 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_PrismaticJoint_GetLocalAnchorA) + +static bool js_PrismaticJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2PrismaticJoint const *)arg1)->GetLocalAnchorB(); + + 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_PrismaticJoint_GetLocalAnchorB) + +static bool js_PrismaticJoint_GetLocalAxisA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2PrismaticJoint const *)arg1)->GetLocalAxisA(); + + 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_PrismaticJoint_GetLocalAxisA) + +static bool js_PrismaticJoint_GetReferenceAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetReferenceAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetReferenceAngle) + +static bool js_PrismaticJoint_GetJointTranslation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetJointTranslation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetJointTranslation) + +static bool js_PrismaticJoint_GetJointSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetJointSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetJointSpeed) + +static bool js_PrismaticJoint_IsLimitEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2PrismaticJoint const *)arg1)->IsLimitEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_IsLimitEnabled) + +static bool js_PrismaticJoint_EnableLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_EnableLimit) + +static bool js_PrismaticJoint_GetLowerLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetLowerLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetLowerLimit) + +static bool js_PrismaticJoint_GetUpperLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetUpperLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetUpperLimit) + +static bool js_PrismaticJoint_SetLimits(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLimits(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_SetLimits) + +static bool js_PrismaticJoint_IsMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2PrismaticJoint const *)arg1)->IsMotorEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_IsMotorEnabled) + +static bool js_PrismaticJoint_EnableMotor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableMotor(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_EnableMotor) + +static bool js_PrismaticJoint_SetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMotorSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_SetMotorSpeed) + +static bool js_PrismaticJoint_GetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetMotorSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetMotorSpeed) + +static bool js_PrismaticJoint_SetMaxMotorForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxMotorForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_SetMaxMotorForce) + +static bool js_PrismaticJoint_GetMaxMotorForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetMaxMotorForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetMaxMotorForce) + +static bool js_PrismaticJoint_GetMotorForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2PrismaticJoint const *)arg1)->GetMotorForce(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetMotorForce) + +static bool js_delete_b2PrismaticJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PrismaticJoint) + +bool js_register_b2PrismaticJoint(se::Object* obj) { + auto* cls = se::Class::create("PrismaticJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_PrismaticJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_PrismaticJoint_GetLocalAnchorB)); + cls->defineFunction("GetLocalAxisA", _SE(js_PrismaticJoint_GetLocalAxisA)); + cls->defineFunction("GetReferenceAngle", _SE(js_PrismaticJoint_GetReferenceAngle)); + cls->defineFunction("GetJointTranslation", _SE(js_PrismaticJoint_GetJointTranslation)); + cls->defineFunction("GetJointSpeed", _SE(js_PrismaticJoint_GetJointSpeed)); + cls->defineFunction("IsLimitEnabled", _SE(js_PrismaticJoint_IsLimitEnabled)); + cls->defineFunction("EnableLimit", _SE(js_PrismaticJoint_EnableLimit)); + cls->defineFunction("GetLowerLimit", _SE(js_PrismaticJoint_GetLowerLimit)); + cls->defineFunction("GetUpperLimit", _SE(js_PrismaticJoint_GetUpperLimit)); + cls->defineFunction("SetLimits", _SE(js_PrismaticJoint_SetLimits)); + cls->defineFunction("IsMotorEnabled", _SE(js_PrismaticJoint_IsMotorEnabled)); + cls->defineFunction("EnableMotor", _SE(js_PrismaticJoint_EnableMotor)); + cls->defineFunction("SetMotorSpeed", _SE(js_PrismaticJoint_SetMotorSpeed)); + cls->defineFunction("GetMotorSpeed", _SE(js_PrismaticJoint_GetMotorSpeed)); + cls->defineFunction("SetMaxMotorForce", _SE(js_PrismaticJoint_SetMaxMotorForce)); + cls->defineFunction("GetMaxMotorForce", _SE(js_PrismaticJoint_GetMaxMotorForce)); + cls->defineFunction("GetMotorForce", _SE(js_PrismaticJoint_GetMotorForce)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PrismaticJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PrismaticJoint_proto = cls->getProto(); + __jsb_b2PrismaticJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PulleyJointDef_class = nullptr; +se::Object* __jsb_b2PulleyJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PulleyJointDef) + +static bool js_new_b2PulleyJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2PulleyJointDef *result; + result = (b2PulleyJointDef *)new b2PulleyJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2PulleyJointDef, __jsb_b2PulleyJointDef_class, js_delete_b2PulleyJointDef) + +static bool js_PulleyJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 *arg6 = 0 ; + b2Vec2 *arg7 = 0 ; + float arg8 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + b2Vec2 temp6 ; + b2Vec2 temp7 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5,(b2Vec2 const &)*arg6,(b2Vec2 const &)*arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_PulleyJointDef_Initialize) + +static bool js_PulleyJointDef_groundAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groundAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_groundAnchorA_set) + +static bool js_PulleyJointDef_groundAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groundAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->groundAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_groundAnchorA_get) + +static bool js_PulleyJointDef_groundAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groundAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_groundAnchorB_set) + +static bool js_PulleyJointDef_groundAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groundAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->groundAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_groundAnchorB_get) + +static bool js_PulleyJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_localAnchorA_set) + +static bool js_PulleyJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_localAnchorA_get) + +static bool js_PulleyJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_localAnchorB_set) + +static bool js_PulleyJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_localAnchorB_get) + +static bool js_PulleyJointDef_lengthA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lengthA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_lengthA_set) + +static bool js_PulleyJointDef_lengthA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lengthA, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_lengthA_get) + +static bool js_PulleyJointDef_lengthB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lengthB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_lengthB_set) + +static bool js_PulleyJointDef_lengthB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lengthB, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_lengthB_get) + +static bool js_PulleyJointDef_ratio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ratio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_ratio_set) + +static bool js_PulleyJointDef_ratio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ratio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_ratio_get) + +static bool js_delete_b2PulleyJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PulleyJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2PulleyJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("groundAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groundAnchorA), ctx); + } + + + json->getProperty("groundAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groundAnchorB), ctx); + } + + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("lengthA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lengthA), ctx); + } + + + json->getProperty("lengthB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lengthB), ctx); + } + + + json->getProperty("ratio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ratio), ctx); + } + + + return ok; +} + + +bool js_register_b2PulleyJointDef(se::Object* obj) { + auto* cls = se::Class::create("PulleyJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2PulleyJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("groundAnchorA", _SE(js_PulleyJointDef_groundAnchorA_get), _SE(js_PulleyJointDef_groundAnchorA_set)); + cls->defineProperty("groundAnchorB", _SE(js_PulleyJointDef_groundAnchorB_get), _SE(js_PulleyJointDef_groundAnchorB_set)); + cls->defineProperty("localAnchorA", _SE(js_PulleyJointDef_localAnchorA_get), _SE(js_PulleyJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_PulleyJointDef_localAnchorB_get), _SE(js_PulleyJointDef_localAnchorB_set)); + cls->defineProperty("lengthA", _SE(js_PulleyJointDef_lengthA_get), _SE(js_PulleyJointDef_lengthA_set)); + cls->defineProperty("lengthB", _SE(js_PulleyJointDef_lengthB_get), _SE(js_PulleyJointDef_lengthB_set)); + cls->defineProperty("ratio", _SE(js_PulleyJointDef_ratio_get), _SE(js_PulleyJointDef_ratio_set)); + + cls->defineFunction("Initialize", _SE(js_PulleyJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PulleyJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PulleyJointDef_proto = cls->getProto(); + __jsb_b2PulleyJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PulleyJoint_class = nullptr; +se::Object* __jsb_b2PulleyJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PulleyJoint) + +static bool js_PulleyJoint_GetGroundAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2PulleyJoint const *)arg1)->GetGroundAnchorA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetGroundAnchorA) + +static bool js_PulleyJoint_GetGroundAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2PulleyJoint const *)arg1)->GetGroundAnchorB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetGroundAnchorB) + +static bool js_PulleyJoint_GetLengthA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetLengthA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetLengthA) + +static bool js_PulleyJoint_GetLengthB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetLengthB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetLengthB) + +static bool js_PulleyJoint_GetRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetRatio) + +static bool js_PulleyJoint_GetCurrentLengthA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetCurrentLengthA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetCurrentLengthA) + +static bool js_PulleyJoint_GetCurrentLengthB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetCurrentLengthB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetCurrentLengthB) + +static bool js_delete_b2PulleyJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PulleyJoint) + +bool js_register_b2PulleyJoint(se::Object* obj) { + auto* cls = se::Class::create("PulleyJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetGroundAnchorA", _SE(js_PulleyJoint_GetGroundAnchorA)); + cls->defineFunction("GetGroundAnchorB", _SE(js_PulleyJoint_GetGroundAnchorB)); + cls->defineFunction("GetLengthA", _SE(js_PulleyJoint_GetLengthA)); + cls->defineFunction("GetLengthB", _SE(js_PulleyJoint_GetLengthB)); + cls->defineFunction("GetRatio", _SE(js_PulleyJoint_GetRatio)); + cls->defineFunction("GetCurrentLengthA", _SE(js_PulleyJoint_GetCurrentLengthA)); + cls->defineFunction("GetCurrentLengthB", _SE(js_PulleyJoint_GetCurrentLengthB)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PulleyJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PulleyJoint_proto = cls->getProto(); + __jsb_b2PulleyJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RevoluteJointDef_class = nullptr; +se::Object* __jsb_b2RevoluteJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RevoluteJointDef) + +static bool js_new_b2RevoluteJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RevoluteJointDef *result; + result = (b2RevoluteJointDef *)new b2RevoluteJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RevoluteJointDef, __jsb_b2RevoluteJointDef_class, js_delete_b2RevoluteJointDef) + +static bool js_RevoluteJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJointDef_Initialize) + +static bool js_RevoluteJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_localAnchorA_set) + +static bool js_RevoluteJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_localAnchorA_get) + +static bool js_RevoluteJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_localAnchorB_set) + +static bool js_RevoluteJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_localAnchorB_get) + +static bool js_RevoluteJointDef_referenceAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->referenceAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_referenceAngle_set) + +static bool js_RevoluteJointDef_referenceAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->referenceAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_referenceAngle_get) + +static bool js_RevoluteJointDef_enableLimit_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableLimit); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_enableLimit_set) + +static bool js_RevoluteJointDef_enableLimit_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableLimit, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_enableLimit_get) + +static bool js_RevoluteJointDef_lowerAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lowerAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_lowerAngle_set) + +static bool js_RevoluteJointDef_lowerAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lowerAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_lowerAngle_get) + +static bool js_RevoluteJointDef_upperAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->upperAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_upperAngle_set) + +static bool js_RevoluteJointDef_upperAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->upperAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_upperAngle_get) + +static bool js_RevoluteJointDef_enableMotor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableMotor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_enableMotor_set) + +static bool js_RevoluteJointDef_enableMotor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableMotor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_enableMotor_get) + +static bool js_RevoluteJointDef_motorSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->motorSpeed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_motorSpeed_set) + +static bool js_RevoluteJointDef_motorSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->motorSpeed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_motorSpeed_get) + +static bool js_RevoluteJointDef_maxMotorTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxMotorTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_maxMotorTorque_set) + +static bool js_RevoluteJointDef_maxMotorTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxMotorTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_maxMotorTorque_get) + +static bool js_delete_b2RevoluteJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RevoluteJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2RevoluteJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("referenceAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->referenceAngle), ctx); + } + + + json->getProperty("enableLimit", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableLimit), ctx); + } + + + json->getProperty("lowerAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lowerAngle), ctx); + } + + + json->getProperty("upperAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->upperAngle), ctx); + } + + + json->getProperty("enableMotor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableMotor), ctx); + } + + + json->getProperty("motorSpeed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->motorSpeed), ctx); + } + + + json->getProperty("maxMotorTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxMotorTorque), ctx); + } + + + return ok; +} + + +bool js_register_b2RevoluteJointDef(se::Object* obj) { + auto* cls = se::Class::create("RevoluteJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2RevoluteJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_RevoluteJointDef_localAnchorA_get), _SE(js_RevoluteJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_RevoluteJointDef_localAnchorB_get), _SE(js_RevoluteJointDef_localAnchorB_set)); + cls->defineProperty("referenceAngle", _SE(js_RevoluteJointDef_referenceAngle_get), _SE(js_RevoluteJointDef_referenceAngle_set)); + cls->defineProperty("enableLimit", _SE(js_RevoluteJointDef_enableLimit_get), _SE(js_RevoluteJointDef_enableLimit_set)); + cls->defineProperty("lowerAngle", _SE(js_RevoluteJointDef_lowerAngle_get), _SE(js_RevoluteJointDef_lowerAngle_set)); + cls->defineProperty("upperAngle", _SE(js_RevoluteJointDef_upperAngle_get), _SE(js_RevoluteJointDef_upperAngle_set)); + cls->defineProperty("enableMotor", _SE(js_RevoluteJointDef_enableMotor_get), _SE(js_RevoluteJointDef_enableMotor_set)); + cls->defineProperty("motorSpeed", _SE(js_RevoluteJointDef_motorSpeed_get), _SE(js_RevoluteJointDef_motorSpeed_set)); + cls->defineProperty("maxMotorTorque", _SE(js_RevoluteJointDef_maxMotorTorque_get), _SE(js_RevoluteJointDef_maxMotorTorque_set)); + + cls->defineFunction("Initialize", _SE(js_RevoluteJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RevoluteJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RevoluteJointDef_proto = cls->getProto(); + __jsb_b2RevoluteJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RevoluteJoint_class = nullptr; +se::Object* __jsb_b2RevoluteJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RevoluteJoint) + +static bool js_RevoluteJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RevoluteJoint const *)arg1)->GetLocalAnchorA(); + + 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_RevoluteJoint_GetLocalAnchorA) + +static bool js_RevoluteJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RevoluteJoint const *)arg1)->GetLocalAnchorB(); + + 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_RevoluteJoint_GetLocalAnchorB) + +static bool js_RevoluteJoint_GetReferenceAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetReferenceAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetReferenceAngle) + +static bool js_RevoluteJoint_GetJointAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetJointAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetJointAngle) + +static bool js_RevoluteJoint_GetJointSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetJointSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetJointSpeed) + +static bool js_RevoluteJoint_IsLimitEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2RevoluteJoint const *)arg1)->IsLimitEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_IsLimitEnabled) + +static bool js_RevoluteJoint_EnableLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_EnableLimit) + +static bool js_RevoluteJoint_GetLowerLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetLowerLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetLowerLimit) + +static bool js_RevoluteJoint_GetUpperLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetUpperLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetUpperLimit) + +static bool js_RevoluteJoint_SetLimits(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLimits(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_SetLimits) + +static bool js_RevoluteJoint_IsMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2RevoluteJoint const *)arg1)->IsMotorEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_IsMotorEnabled) + +static bool js_RevoluteJoint_EnableMotor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableMotor(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_EnableMotor) + +static bool js_RevoluteJoint_SetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMotorSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_SetMotorSpeed) + +static bool js_RevoluteJoint_GetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetMotorSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetMotorSpeed) + +static bool js_RevoluteJoint_SetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxMotorTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_SetMaxMotorTorque) + +static bool js_RevoluteJoint_GetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetMaxMotorTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetMaxMotorTorque) + +static bool js_RevoluteJoint_GetMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2RevoluteJoint const *)arg1)->GetMotorTorque(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetMotorTorque) + +static bool js_delete_b2RevoluteJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RevoluteJoint) + +bool js_register_b2RevoluteJoint(se::Object* obj) { + auto* cls = se::Class::create("RevoluteJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_RevoluteJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_RevoluteJoint_GetLocalAnchorB)); + cls->defineFunction("GetReferenceAngle", _SE(js_RevoluteJoint_GetReferenceAngle)); + cls->defineFunction("GetJointAngle", _SE(js_RevoluteJoint_GetJointAngle)); + cls->defineFunction("GetJointSpeed", _SE(js_RevoluteJoint_GetJointSpeed)); + cls->defineFunction("IsLimitEnabled", _SE(js_RevoluteJoint_IsLimitEnabled)); + cls->defineFunction("EnableLimit", _SE(js_RevoluteJoint_EnableLimit)); + cls->defineFunction("GetLowerLimit", _SE(js_RevoluteJoint_GetLowerLimit)); + cls->defineFunction("GetUpperLimit", _SE(js_RevoluteJoint_GetUpperLimit)); + cls->defineFunction("SetLimits", _SE(js_RevoluteJoint_SetLimits)); + cls->defineFunction("IsMotorEnabled", _SE(js_RevoluteJoint_IsMotorEnabled)); + cls->defineFunction("EnableMotor", _SE(js_RevoluteJoint_EnableMotor)); + cls->defineFunction("SetMotorSpeed", _SE(js_RevoluteJoint_SetMotorSpeed)); + cls->defineFunction("GetMotorSpeed", _SE(js_RevoluteJoint_GetMotorSpeed)); + cls->defineFunction("SetMaxMotorTorque", _SE(js_RevoluteJoint_SetMaxMotorTorque)); + cls->defineFunction("GetMaxMotorTorque", _SE(js_RevoluteJoint_GetMaxMotorTorque)); + cls->defineFunction("GetMotorTorque", _SE(js_RevoluteJoint_GetMotorTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RevoluteJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RevoluteJoint_proto = cls->getProto(); + __jsb_b2RevoluteJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WeldJointDef_class = nullptr; +se::Object* __jsb_b2WeldJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WeldJointDef) + +static bool js_new_b2WeldJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2WeldJointDef *result; + result = (b2WeldJointDef *)new b2WeldJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2WeldJointDef, __jsb_b2WeldJointDef_class, js_delete_b2WeldJointDef) + +static bool js_WeldJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_WeldJointDef_Initialize) + +static bool js_WeldJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_localAnchorA_set) + +static bool js_WeldJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_localAnchorA_get) + +static bool js_WeldJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_localAnchorB_set) + +static bool js_WeldJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_localAnchorB_get) + +static bool js_WeldJointDef_referenceAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->referenceAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_referenceAngle_set) + +static bool js_WeldJointDef_referenceAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->referenceAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_referenceAngle_get) + +static bool js_WeldJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_frequencyHz_set) + +static bool js_WeldJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_frequencyHz_get) + +static bool js_WeldJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_dampingRatio_set) + +static bool js_WeldJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_dampingRatio_get) + +static bool js_delete_b2WeldJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WeldJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2WeldJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("referenceAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->referenceAngle), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2WeldJointDef(se::Object* obj) { + auto* cls = se::Class::create("WeldJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2WeldJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_WeldJointDef_localAnchorA_get), _SE(js_WeldJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_WeldJointDef_localAnchorB_get), _SE(js_WeldJointDef_localAnchorB_set)); + cls->defineProperty("referenceAngle", _SE(js_WeldJointDef_referenceAngle_get), _SE(js_WeldJointDef_referenceAngle_set)); + cls->defineProperty("frequencyHz", _SE(js_WeldJointDef_frequencyHz_get), _SE(js_WeldJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_WeldJointDef_dampingRatio_get), _SE(js_WeldJointDef_dampingRatio_set)); + + cls->defineFunction("Initialize", _SE(js_WeldJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WeldJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WeldJointDef_proto = cls->getProto(); + __jsb_b2WeldJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WeldJoint_class = nullptr; +se::Object* __jsb_b2WeldJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WeldJoint) + +static bool js_WeldJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WeldJoint const *)arg1)->GetLocalAnchorA(); + + 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_WeldJoint_GetLocalAnchorA) + +static bool js_WeldJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WeldJoint const *)arg1)->GetLocalAnchorB(); + + 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_WeldJoint_GetLocalAnchorB) + +static bool js_WeldJoint_GetReferenceAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WeldJoint const *)arg1)->GetReferenceAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_GetReferenceAngle) + +static bool js_WeldJoint_SetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFrequency(arg2); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_SetFrequency) + +static bool js_WeldJoint_GetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WeldJoint const *)arg1)->GetFrequency(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_GetFrequency) + +static bool js_WeldJoint_SetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_SetDampingRatio) + +static bool js_WeldJoint_GetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WeldJoint const *)arg1)->GetDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_GetDampingRatio) + +static bool js_delete_b2WeldJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WeldJoint) + +bool js_register_b2WeldJoint(se::Object* obj) { + auto* cls = se::Class::create("WeldJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_WeldJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_WeldJoint_GetLocalAnchorB)); + cls->defineFunction("GetReferenceAngle", _SE(js_WeldJoint_GetReferenceAngle)); + cls->defineFunction("SetFrequency", _SE(js_WeldJoint_SetFrequency)); + cls->defineFunction("GetFrequency", _SE(js_WeldJoint_GetFrequency)); + cls->defineFunction("SetDampingRatio", _SE(js_WeldJoint_SetDampingRatio)); + cls->defineFunction("GetDampingRatio", _SE(js_WeldJoint_GetDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WeldJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WeldJoint_proto = cls->getProto(); + __jsb_b2WeldJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WheelJointDef_class = nullptr; +se::Object* __jsb_b2WheelJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WheelJointDef) + +static bool js_new_b2WheelJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2WheelJointDef *result; + result = (b2WheelJointDef *)new b2WheelJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2WheelJointDef, __jsb_b2WheelJointDef_class, js_delete_b2WheelJointDef) + +static bool js_WheelJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_WheelJointDef_Initialize) + +static bool js_WheelJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_localAnchorA_set) + +static bool js_WheelJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_localAnchorA_get) + +static bool js_WheelJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_localAnchorB_set) + +static bool js_WheelJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_localAnchorB_get) + +static bool js_WheelJointDef_localAxisA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAxisA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_localAxisA_set) + +static bool js_WheelJointDef_localAxisA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAxisA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAxisA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_localAxisA_get) + +static bool js_WheelJointDef_enableMotor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableMotor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_enableMotor_set) + +static bool js_WheelJointDef_enableMotor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableMotor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_enableMotor_get) + +static bool js_WheelJointDef_maxMotorTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxMotorTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_maxMotorTorque_set) + +static bool js_WheelJointDef_maxMotorTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxMotorTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_maxMotorTorque_get) + +static bool js_WheelJointDef_motorSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->motorSpeed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_motorSpeed_set) + +static bool js_WheelJointDef_motorSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->motorSpeed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_motorSpeed_get) + +static bool js_WheelJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_frequencyHz_set) + +static bool js_WheelJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_frequencyHz_get) + +static bool js_WheelJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_dampingRatio_set) + +static bool js_WheelJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_dampingRatio_get) + +static bool js_delete_b2WheelJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WheelJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2WheelJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("localAxisA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAxisA), ctx); + } + + + json->getProperty("enableMotor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableMotor), ctx); + } + + + json->getProperty("maxMotorTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxMotorTorque), ctx); + } + + + json->getProperty("motorSpeed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->motorSpeed), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2WheelJointDef(se::Object* obj) { + auto* cls = se::Class::create("WheelJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2WheelJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_WheelJointDef_localAnchorA_get), _SE(js_WheelJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_WheelJointDef_localAnchorB_get), _SE(js_WheelJointDef_localAnchorB_set)); + cls->defineProperty("localAxisA", _SE(js_WheelJointDef_localAxisA_get), _SE(js_WheelJointDef_localAxisA_set)); + cls->defineProperty("enableMotor", _SE(js_WheelJointDef_enableMotor_get), _SE(js_WheelJointDef_enableMotor_set)); + cls->defineProperty("maxMotorTorque", _SE(js_WheelJointDef_maxMotorTorque_get), _SE(js_WheelJointDef_maxMotorTorque_set)); + cls->defineProperty("motorSpeed", _SE(js_WheelJointDef_motorSpeed_get), _SE(js_WheelJointDef_motorSpeed_set)); + cls->defineProperty("frequencyHz", _SE(js_WheelJointDef_frequencyHz_get), _SE(js_WheelJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_WheelJointDef_dampingRatio_get), _SE(js_WheelJointDef_dampingRatio_set)); + + cls->defineFunction("Initialize", _SE(js_WheelJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WheelJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WheelJointDef_proto = cls->getProto(); + __jsb_b2WheelJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WheelJoint_class = nullptr; +se::Object* __jsb_b2WheelJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WheelJoint) + +static bool js_WheelJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WheelJoint const *)arg1)->GetLocalAnchorA(); + + 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_WheelJoint_GetLocalAnchorA) + +static bool js_WheelJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WheelJoint const *)arg1)->GetLocalAnchorB(); + + 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_WheelJoint_GetLocalAnchorB) + +static bool js_WheelJoint_GetLocalAxisA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WheelJoint const *)arg1)->GetLocalAxisA(); + + 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_WheelJoint_GetLocalAxisA) + +static bool js_WheelJoint_GetJointTranslation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointTranslation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointTranslation) + +static bool js_WheelJoint_GetJointLinearSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointLinearSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointLinearSpeed) + +static bool js_WheelJoint_GetJointAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointAngle) + +static bool js_WheelJoint_GetJointAngularSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointAngularSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointAngularSpeed) + +static bool js_WheelJoint_IsMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2WheelJoint const *)arg1)->IsMotorEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_IsMotorEnabled) + +static bool js_WheelJoint_EnableMotor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableMotor(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_EnableMotor) + +static bool js_WheelJoint_SetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMotorSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetMotorSpeed) + +static bool js_WheelJoint_GetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetMotorSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetMotorSpeed) + +static bool js_WheelJoint_SetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxMotorTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetMaxMotorTorque) + +static bool js_WheelJoint_GetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetMaxMotorTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetMaxMotorTorque) + +static bool js_WheelJoint_GetMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2WheelJoint const *)arg1)->GetMotorTorque(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetMotorTorque) + +static bool js_WheelJoint_SetSpringFrequencyHz(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSpringFrequencyHz(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetSpringFrequencyHz) + +static bool js_WheelJoint_GetSpringFrequencyHz(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetSpringFrequencyHz(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetSpringFrequencyHz) + +static bool js_WheelJoint_SetSpringDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSpringDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetSpringDampingRatio) + +static bool js_WheelJoint_GetSpringDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetSpringDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetSpringDampingRatio) + +static bool js_delete_b2WheelJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WheelJoint) + +bool js_register_b2WheelJoint(se::Object* obj) { + auto* cls = se::Class::create("WheelJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_WheelJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_WheelJoint_GetLocalAnchorB)); + cls->defineFunction("GetLocalAxisA", _SE(js_WheelJoint_GetLocalAxisA)); + cls->defineFunction("GetJointTranslation", _SE(js_WheelJoint_GetJointTranslation)); + cls->defineFunction("GetJointLinearSpeed", _SE(js_WheelJoint_GetJointLinearSpeed)); + cls->defineFunction("GetJointAngle", _SE(js_WheelJoint_GetJointAngle)); + cls->defineFunction("GetJointAngularSpeed", _SE(js_WheelJoint_GetJointAngularSpeed)); + cls->defineFunction("IsMotorEnabled", _SE(js_WheelJoint_IsMotorEnabled)); + cls->defineFunction("EnableMotor", _SE(js_WheelJoint_EnableMotor)); + cls->defineFunction("SetMotorSpeed", _SE(js_WheelJoint_SetMotorSpeed)); + cls->defineFunction("GetMotorSpeed", _SE(js_WheelJoint_GetMotorSpeed)); + cls->defineFunction("SetMaxMotorTorque", _SE(js_WheelJoint_SetMaxMotorTorque)); + cls->defineFunction("GetMaxMotorTorque", _SE(js_WheelJoint_GetMaxMotorTorque)); + cls->defineFunction("GetMotorTorque", _SE(js_WheelJoint_GetMotorTorque)); + cls->defineFunction("SetSpringFrequencyHz", _SE(js_WheelJoint_SetSpringFrequencyHz)); + cls->defineFunction("GetSpringFrequencyHz", _SE(js_WheelJoint_GetSpringFrequencyHz)); + cls->defineFunction("SetSpringDampingRatio", _SE(js_WheelJoint_SetSpringDampingRatio)); + cls->defineFunction("GetSpringDampingRatio", _SE(js_WheelJoint_GetSpringDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WheelJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WheelJoint_proto = cls->getProto(); + __jsb_b2WheelJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSBQueryCallback_class = nullptr; +se::Object* __jsb_JSBQueryCallback_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSBQueryCallback) + +static bool js_new_JSBQueryCallback(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSBQueryCallback *result; + result = (JSBQueryCallback *)new JSBQueryCallback(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSBQueryCallback, __jsb_JSBQueryCallback_class, js_delete_JSBQueryCallback) + +static bool js_delete_JSBQueryCallback(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSBQueryCallback) + +static bool js_QueryCallback_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBQueryCallback *arg1 = (JSBQueryCallback *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_QueryCallback_initWithThis) + +static bool js_QueryCallback_ReportFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBQueryCallback *arg1 = (JSBQueryCallback *) NULL ; + b2Fixture *arg2 = (b2Fixture *) 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(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)->ReportFixture(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_QueryCallback_ReportFixture) + +bool js_register_JSBQueryCallback(se::Object* obj) { + auto* cls = se::Class::create("QueryCallback", obj, nullptr, _SE(js_new_JSBQueryCallback)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_QueryCallback_initWithThis)); + cls->defineFunction("ReportFixture", _SE(js_QueryCallback_ReportFixture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSBQueryCallback)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSBQueryCallback_proto = cls->getProto(); + __jsb_JSBQueryCallback_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSBRayCastCallback_class = nullptr; +se::Object* __jsb_JSBRayCastCallback_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSBRayCastCallback) + +static bool js_new_JSBRayCastCallback(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSBRayCastCallback *result; + result = (JSBRayCastCallback *)new JSBRayCastCallback(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSBRayCastCallback, __jsb_JSBRayCastCallback_class, js_delete_JSBRayCastCallback) + +static bool js_delete_JSBRayCastCallback(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSBRayCastCallback) + +static bool js_RayCastCallback_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBRayCastCallback *arg1 = (JSBRayCastCallback *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_RayCastCallback_initWithThis) + +static bool js_RayCastCallback_ReportFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBRayCastCallback *arg1 = (JSBRayCastCallback *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + b2Vec2 *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + float arg5 ; + b2Vec2 temp3 ; + b2Vec2 temp4 ; + float result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->ReportFixture(arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RayCastCallback_ReportFixture) + +bool js_register_JSBRayCastCallback(se::Object* obj) { + auto* cls = se::Class::create("RayCastCallback", obj, nullptr, _SE(js_new_JSBRayCastCallback)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_RayCastCallback_initWithThis)); + cls->defineFunction("ReportFixture", _SE(js_RayCastCallback_ReportFixture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSBRayCastCallback)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSBRayCastCallback_proto = cls->getProto(); + __jsb_JSBRayCastCallback_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSBB2Draw_class = nullptr; +se::Object* __jsb_JSBB2Draw_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSBB2Draw) + +static bool js_new_JSBB2Draw(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSBB2Draw *result; + result = (JSBB2Draw *)new JSBB2Draw(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSBB2Draw, __jsb_JSBB2Draw_class, js_delete_JSBB2Draw) + +static bool js_delete_JSBB2Draw(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSBB2Draw) + +static bool js_Draw_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_initWithThis) + +static bool js_Draw_DrawPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = (b2Vec2 *) NULL ; + int32 arg3 ; + b2Color *arg4 = 0 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->DrawPolygon((b2Vec2 const *)arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawPolygon) + +static bool js_Draw_DrawSolidPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = (b2Vec2 *) NULL ; + int32 arg3 ; + b2Color *arg4 = 0 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->DrawSolidPolygon((b2Vec2 const *)arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawSolidPolygon) + +static bool js_Draw_DrawCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Color *arg4 = 0 ; + b2Vec2 temp2 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->DrawCircle((b2Vec2 const &)*arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawCircle) + +static bool js_Draw_DrawSolidCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Vec2 *arg4 = 0 ; + b2Color *arg5 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp4 ; + b2Color temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->DrawSolidCircle((b2Vec2 const &)*arg2,arg3,(b2Vec2 const &)*arg4,(b2Color const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawSolidCircle) + +static bool js_Draw_DrawSegment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Color *arg4 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->DrawSegment((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawSegment) + +static bool js_Draw_DrawTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Transform *arg2 = 0 ; + b2Transform temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->DrawTransform((b2Transform const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawTransform) + +static bool js_Draw_DrawPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Color *arg4 = 0 ; + b2Vec2 temp2 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->DrawPoint((b2Vec2 const &)*arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawPoint) + +static bool js_Draw_SetFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->SetFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_SetFlags) + +static bool js_Draw_GetFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((JSBB2Draw const *)arg1)->GetFlags(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Draw_GetFlags) + +static bool js_Draw_AppendFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->AppendFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_AppendFlags) + +static bool js_Draw_ClearFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->ClearFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_ClearFlags) + +bool js_register_JSBB2Draw(se::Object* obj) { + auto* cls = se::Class::create("Draw", obj, nullptr, _SE(js_new_JSBB2Draw)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_Draw_initWithThis)); + cls->defineFunction("DrawPolygon", _SE(js_Draw_DrawPolygon)); + cls->defineFunction("DrawSolidPolygon", _SE(js_Draw_DrawSolidPolygon)); + cls->defineFunction("DrawCircle", _SE(js_Draw_DrawCircle)); + cls->defineFunction("DrawSolidCircle", _SE(js_Draw_DrawSolidCircle)); + cls->defineFunction("DrawSegment", _SE(js_Draw_DrawSegment)); + cls->defineFunction("DrawTransform", _SE(js_Draw_DrawTransform)); + cls->defineFunction("DrawPoint", _SE(js_Draw_DrawPoint)); + cls->defineFunction("SetFlags", _SE(js_Draw_SetFlags)); + cls->defineFunction("GetFlags", _SE(js_Draw_GetFlags)); + cls->defineFunction("AppendFlags", _SE(js_Draw_AppendFlags)); + cls->defineFunction("ClearFlags", _SE(js_Draw_ClearFlags)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSBB2Draw)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSBB2Draw_proto = cls->getProto(); + __jsb_JSBB2Draw_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSB_b2ContactListener_class = nullptr; +se::Object* __jsb_JSB_b2ContactListener_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSB_b2ContactListener) + +static bool js_new_JSB_b2ContactListener(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSB_b2ContactListener *result; + result = (JSB_b2ContactListener *)new JSB_b2ContactListener(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSB_b2ContactListener, __jsb_JSB_b2ContactListener_class, js_delete_JSB_b2ContactListener) + +static bool js_delete_JSB_b2ContactListener(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSB_b2ContactListener) + +static bool js_ContactListener_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_initWithThis) + +static bool js_ContactListener_BeginContact(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->BeginContact(arg2); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_BeginContact) + +static bool js_ContactListener_EndContact(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EndContact(arg2); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_EndContact) + +static bool js_ContactListener_PreSolve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + b2Manifold *arg3 = (b2Manifold *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->PreSolve(arg2,(b2Manifold const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_PreSolve) + +static bool js_ContactListener_PostSolve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + b2ContactImpulse *arg3 = (b2ContactImpulse *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->PostSolve(arg2,(b2ContactImpulse const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_PostSolve) + +bool js_register_JSB_b2ContactListener(se::Object* obj) { + auto* cls = se::Class::create("ContactListener", obj, nullptr, _SE(js_new_JSB_b2ContactListener)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_ContactListener_initWithThis)); + cls->defineFunction("BeginContact", _SE(js_ContactListener_BeginContact)); + cls->defineFunction("EndContact", _SE(js_ContactListener_EndContact)); + cls->defineFunction("PreSolve", _SE(js_ContactListener_PreSolve)); + cls->defineFunction("PostSolve", _SE(js_ContactListener_PostSolve)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSB_b2ContactListener)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSB_b2ContactListener_proto = cls->getProto(); + __jsb_JSB_b2ContactListener_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_box2d(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("b2jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("b2jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_b2Vec2(ns); + js_register_b2Vec3(ns); + js_register_b2Mat22(ns); + js_register_b2Mat33(ns); + js_register_b2Rot(ns); + js_register_b2Transform(ns); + js_register_b2Sweep(ns); + js_register_b2MassData(ns); + js_register_b2Shape(ns); + js_register_b2Color(ns); + js_register_b2ContactFeature(ns); + js_register_b2ContactID(ns); + js_register_b2ManifoldPoint(ns); + js_register_b2Manifold(ns); + js_register_b2WorldManifold(ns); + js_register_b2ClipVertex(ns); + js_register_b2RayCastInput(ns); + js_register_b2RayCastOutput(ns); + js_register_b2AABB(ns); + js_register_b2Jacobian(ns); + js_register_b2JointEdge(ns); + js_register_b2JointDef(ns); + js_register_b2Joint(ns); + js_register_b2ChainShape(ns); + js_register_b2CircleShape(ns); + js_register_b2EdgeShape(ns); + js_register_b2PolygonShape(ns); + js_register_b2Pair(ns); + js_register_b2BroadPhase(ns); + js_register_b2TreeNode(ns); + js_register_b2DynamicTree(ns); + js_register_b2BodyDef(ns); + js_register_b2Body(ns); + js_register_b2ContactEdge(ns); + js_register_b2Contact(ns); + js_register_b2Filter(ns); + js_register_b2FixtureDef(ns); + js_register_b2FixtureProxy(ns); + js_register_b2Fixture(ns); + js_register_b2Profile(ns); + js_register_b2TimeStep(ns); + js_register_b2Position(ns); + js_register_b2Velocity(ns); + js_register_b2SolverData(ns); + js_register_b2World(ns); + js_register_b2DestructionListener(ns); + js_register_b2ContactFilter(ns); + js_register_b2ContactImpulse(ns); + js_register_b2RopeJointDef(ns); + js_register_b2RopeJoint(ns); + js_register_b2FrictionJointDef(ns); + js_register_b2FrictionJoint(ns); + js_register_b2DistanceJointDef(ns); + js_register_b2DistanceJoint(ns); + js_register_b2GearJointDef(ns); + js_register_b2GearJoint(ns); + js_register_b2MotorJointDef(ns); + js_register_b2MotorJoint(ns); + js_register_b2MouseJointDef(ns); + js_register_b2MouseJoint(ns); + js_register_b2PrismaticJointDef(ns); + js_register_b2PrismaticJoint(ns); + js_register_b2PulleyJointDef(ns); + js_register_b2PulleyJoint(ns); + js_register_b2RevoluteJointDef(ns); + js_register_b2RevoluteJoint(ns); + js_register_b2WeldJointDef(ns); + js_register_b2WeldJoint(ns); + js_register_b2WheelJointDef(ns); + js_register_b2WheelJoint(ns); + js_register_JSBQueryCallback(ns); + js_register_JSBRayCastCallback(ns); + js_register_JSBB2Draw(ns); + js_register_JSB_b2ContactListener(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_box2d_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_box2d_auto.h new file mode 100644 index 0000000000..6392896a36 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_box2d_auto.h @@ -0,0 +1,590 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/Box2dCallbacks.h" + + + +bool register_all_box2d(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(b2Vec2); +extern se::Object *__jsb_b2Vec2_proto; // NOLINT +extern se::Class * __jsb_b2Vec2_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec2 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Vec3); +extern se::Object *__jsb_b2Vec3_proto; // NOLINT +extern se::Class * __jsb_b2Vec3_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec3 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Mat22); +extern se::Object *__jsb_b2Mat22_proto; // NOLINT +extern se::Class * __jsb_b2Mat22_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat22 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Mat33); +extern se::Object *__jsb_b2Mat33_proto; // NOLINT +extern se::Class * __jsb_b2Mat33_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat33 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Rot); +extern se::Object *__jsb_b2Rot_proto; // NOLINT +extern se::Class * __jsb_b2Rot_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Rot * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Transform); +extern se::Object *__jsb_b2Transform_proto; // NOLINT +extern se::Class * __jsb_b2Transform_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Transform * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Sweep); +extern se::Object *__jsb_b2Sweep_proto; // NOLINT +extern se::Class * __jsb_b2Sweep_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Sweep * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2MassData); +extern se::Object *__jsb_b2MassData_proto; // NOLINT +extern se::Class * __jsb_b2MassData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2MassData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Shape); +extern se::Object *__jsb_b2Shape_proto; // NOLINT +extern se::Class * __jsb_b2Shape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Color); +extern se::Object *__jsb_b2Color_proto; // NOLINT +extern se::Class * __jsb_b2Color_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Color * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2ContactFeature); +extern se::Object *__jsb_b2ContactFeature_proto; // NOLINT +extern se::Class * __jsb_b2ContactFeature_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactFeature * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2ContactID); +extern se::Object *__jsb_b2ContactID_proto; // NOLINT +extern se::Class * __jsb_b2ContactID_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ManifoldPoint); +extern se::Object *__jsb_b2ManifoldPoint_proto; // NOLINT +extern se::Class * __jsb_b2ManifoldPoint_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ManifoldPoint * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Manifold); +extern se::Object *__jsb_b2Manifold_proto; // NOLINT +extern se::Class * __jsb_b2Manifold_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Manifold * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2WorldManifold); +extern se::Object *__jsb_b2WorldManifold_proto; // NOLINT +extern se::Class * __jsb_b2WorldManifold_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2WorldManifold * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2ClipVertex); +extern se::Object *__jsb_b2ClipVertex_proto; // NOLINT +extern se::Class * __jsb_b2ClipVertex_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ClipVertex * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RayCastInput); +extern se::Object *__jsb_b2RayCastInput_proto; // NOLINT +extern se::Class * __jsb_b2RayCastInput_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastInput * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RayCastOutput); +extern se::Object *__jsb_b2RayCastOutput_proto; // NOLINT +extern se::Class * __jsb_b2RayCastOutput_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastOutput * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2AABB); +extern se::Object *__jsb_b2AABB_proto; // NOLINT +extern se::Class * __jsb_b2AABB_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2AABB * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Jacobian); +extern se::Object *__jsb_b2Jacobian_proto; // NOLINT +extern se::Class * __jsb_b2Jacobian_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Jacobian * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2JointEdge); +extern se::Object *__jsb_b2JointEdge_proto; // NOLINT +extern se::Class * __jsb_b2JointEdge_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2JointEdge * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2JointDef); +extern se::Object *__jsb_b2JointDef_proto; // NOLINT +extern se::Class * __jsb_b2JointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2JointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Joint); +extern se::Object *__jsb_b2Joint_proto; // NOLINT +extern se::Class * __jsb_b2Joint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ChainShape); +extern se::Object *__jsb_b2ChainShape_proto; // NOLINT +extern se::Class * __jsb_b2ChainShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2CircleShape); +extern se::Object *__jsb_b2CircleShape_proto; // NOLINT +extern se::Class * __jsb_b2CircleShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2EdgeShape); +extern se::Object *__jsb_b2EdgeShape_proto; // NOLINT +extern se::Class * __jsb_b2EdgeShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2PolygonShape); +extern se::Object *__jsb_b2PolygonShape_proto; // NOLINT +extern se::Class * __jsb_b2PolygonShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Pair); +extern se::Object *__jsb_b2Pair_proto; // NOLINT +extern se::Class * __jsb_b2Pair_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Pair * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2BroadPhase); +extern se::Object *__jsb_b2BroadPhase_proto; // NOLINT +extern se::Class * __jsb_b2BroadPhase_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2TreeNode); +extern se::Object *__jsb_b2TreeNode_proto; // NOLINT +extern se::Class * __jsb_b2TreeNode_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2TreeNode * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2DynamicTree); +extern se::Object *__jsb_b2DynamicTree_proto; // NOLINT +extern se::Class * __jsb_b2DynamicTree_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2BodyDef); +extern se::Object *__jsb_b2BodyDef_proto; // NOLINT +extern se::Class * __jsb_b2BodyDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2BodyDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Body); +extern se::Object *__jsb_b2Body_proto; // NOLINT +extern se::Class * __jsb_b2Body_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ContactEdge); +extern se::Object *__jsb_b2ContactEdge_proto; // NOLINT +extern se::Class * __jsb_b2ContactEdge_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactEdge * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Contact); +extern se::Object *__jsb_b2Contact_proto; // NOLINT +extern se::Class * __jsb_b2Contact_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Filter); +extern se::Object *__jsb_b2Filter_proto; // NOLINT +extern se::Class * __jsb_b2Filter_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Filter * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2FixtureDef); +extern se::Object *__jsb_b2FixtureDef_proto; // NOLINT +extern se::Class * __jsb_b2FixtureDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2FixtureProxy); +extern se::Object *__jsb_b2FixtureProxy_proto; // NOLINT +extern se::Class * __jsb_b2FixtureProxy_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureProxy * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Fixture); +extern se::Object *__jsb_b2Fixture_proto; // NOLINT +extern se::Class * __jsb_b2Fixture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Profile); +extern se::Object *__jsb_b2Profile_proto; // NOLINT +extern se::Class * __jsb_b2Profile_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Profile * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2TimeStep); +extern se::Object *__jsb_b2TimeStep_proto; // NOLINT +extern se::Class * __jsb_b2TimeStep_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2TimeStep * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Position); +extern se::Object *__jsb_b2Position_proto; // NOLINT +extern se::Class * __jsb_b2Position_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Position * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Velocity); +extern se::Object *__jsb_b2Velocity_proto; // NOLINT +extern se::Class * __jsb_b2Velocity_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Velocity * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2SolverData); +extern se::Object *__jsb_b2SolverData_proto; // NOLINT +extern se::Class * __jsb_b2SolverData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2SolverData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2World); +extern se::Object *__jsb_b2World_proto; // NOLINT +extern se::Class * __jsb_b2World_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2DestructionListener); +extern se::Object *__jsb_b2DestructionListener_proto; // NOLINT +extern se::Class * __jsb_b2DestructionListener_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ContactFilter); +extern se::Object *__jsb_b2ContactFilter_proto; // NOLINT +extern se::Class * __jsb_b2ContactFilter_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ContactImpulse); +extern se::Object *__jsb_b2ContactImpulse_proto; // NOLINT +extern se::Class * __jsb_b2ContactImpulse_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactImpulse * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RopeJointDef); +extern se::Object *__jsb_b2RopeJointDef_proto; // NOLINT +extern se::Class * __jsb_b2RopeJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RopeJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RopeJoint); +extern se::Object *__jsb_b2RopeJoint_proto; // NOLINT +extern se::Class * __jsb_b2RopeJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2FrictionJointDef); +extern se::Object *__jsb_b2FrictionJointDef_proto; // NOLINT +extern se::Class * __jsb_b2FrictionJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2FrictionJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2FrictionJoint); +extern se::Object *__jsb_b2FrictionJoint_proto; // NOLINT +extern se::Class * __jsb_b2FrictionJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2DistanceJointDef); +extern se::Object *__jsb_b2DistanceJointDef_proto; // NOLINT +extern se::Class * __jsb_b2DistanceJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2DistanceJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2DistanceJoint); +extern se::Object *__jsb_b2DistanceJoint_proto; // NOLINT +extern se::Class * __jsb_b2DistanceJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2GearJointDef); +extern se::Object *__jsb_b2GearJointDef_proto; // NOLINT +extern se::Class * __jsb_b2GearJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2GearJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2GearJoint); +extern se::Object *__jsb_b2GearJoint_proto; // NOLINT +extern se::Class * __jsb_b2GearJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2MotorJointDef); +extern se::Object *__jsb_b2MotorJointDef_proto; // NOLINT +extern se::Class * __jsb_b2MotorJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2MotorJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2MotorJoint); +extern se::Object *__jsb_b2MotorJoint_proto; // NOLINT +extern se::Class * __jsb_b2MotorJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2MouseJointDef); +extern se::Object *__jsb_b2MouseJointDef_proto; // NOLINT +extern se::Class * __jsb_b2MouseJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2MouseJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2MouseJoint); +extern se::Object *__jsb_b2MouseJoint_proto; // NOLINT +extern se::Class * __jsb_b2MouseJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2PrismaticJointDef); +extern se::Object *__jsb_b2PrismaticJointDef_proto; // NOLINT +extern se::Class * __jsb_b2PrismaticJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2PrismaticJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2PrismaticJoint); +extern se::Object *__jsb_b2PrismaticJoint_proto; // NOLINT +extern se::Class * __jsb_b2PrismaticJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2PulleyJointDef); +extern se::Object *__jsb_b2PulleyJointDef_proto; // NOLINT +extern se::Class * __jsb_b2PulleyJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2PulleyJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2PulleyJoint); +extern se::Object *__jsb_b2PulleyJoint_proto; // NOLINT +extern se::Class * __jsb_b2PulleyJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2RevoluteJointDef); +extern se::Object *__jsb_b2RevoluteJointDef_proto; // NOLINT +extern se::Class * __jsb_b2RevoluteJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RevoluteJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RevoluteJoint); +extern se::Object *__jsb_b2RevoluteJoint_proto; // NOLINT +extern se::Class * __jsb_b2RevoluteJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2WeldJointDef); +extern se::Object *__jsb_b2WeldJointDef_proto; // NOLINT +extern se::Class * __jsb_b2WeldJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2WeldJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2WeldJoint); +extern se::Object *__jsb_b2WeldJoint_proto; // NOLINT +extern se::Class * __jsb_b2WeldJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2WheelJointDef); +extern se::Object *__jsb_b2WheelJointDef_proto; // NOLINT +extern se::Class * __jsb_b2WheelJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2WheelJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2WheelJoint); +extern se::Object *__jsb_b2WheelJoint_proto; // NOLINT +extern se::Class * __jsb_b2WheelJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSBQueryCallback); +extern se::Object *__jsb_JSBQueryCallback_proto; // NOLINT +extern se::Class * __jsb_JSBQueryCallback_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSBRayCastCallback); +extern se::Object *__jsb_JSBRayCastCallback_proto; // NOLINT +extern se::Class * __jsb_JSBRayCastCallback_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSBB2Draw); +extern se::Object *__jsb_JSBB2Draw_proto; // NOLINT +extern se::Class * __jsb_JSBB2Draw_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSB_b2ContactListener); +extern se::Object *__jsb_JSB_b2ContactListener_proto; // NOLINT +extern se::Class * __jsb_JSB_b2ContactListener_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_cocos_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_cocos_auto.cpp new file mode 100644 index 0000000000..7187460b4f --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_cocos_auto.cpp @@ -0,0 +1,6672 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" + + +#define cc_ICanvasRenderingContext2D_width_set(self_, val_) self_->setWidth(val_) + + +#define cc_ICanvasRenderingContext2D_height_set(self_, val_) self_->setHeight(val_) + + +#define cc_ICanvasRenderingContext2D_lineWidth_set(self_, val_) self_->setLineWidth(val_) + + +#define cc_ICanvasRenderingContext2D_fillStyle_set(self_, val_) self_->setFillStyle(val_) + + +#define cc_ICanvasRenderingContext2D_font_set(self_, val_) self_->setFont(val_) + + +#define cc_ICanvasRenderingContext2D_globalCompositeOperation_set(self_, val_) self_->setGlobalCompositeOperation(val_) + + +#define cc_ICanvasRenderingContext2D_lineCap_set(self_, val_) self_->setLineCap(val_) + + +#define cc_ICanvasRenderingContext2D_strokeStyle_set(self_, val_) self_->setStrokeStyle(val_) + + +#define cc_ICanvasRenderingContext2D_lineJoin_set(self_, val_) self_->setLineJoin(val_) + + +#define cc_ICanvasRenderingContext2D_textAlign_set(self_, val_) self_->setTextAlign(val_) + + +#define cc_ICanvasRenderingContext2D_textBaseline_set(self_, val_) self_->setTextBaseline(val_) + + +#define cc_CCObject_name_get(self_) self_->getName() +#define cc_CCObject_name_set(self_, val_) self_->setName(val_) + + +#define cc_CCObject_hideFlags_get(self_) self_->getHideFlags() +#define cc_CCObject_hideFlags_set(self_, val_) self_->setHideFlags(val_) + + +#define cc_CCObject_isValid_get(self_) self_->isValid() + + + +static bool js_cc_clampf(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::clampf(arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_clampf) + +se::Class* __jsb_cc_Vec2_class = nullptr; +se::Object* __jsb_cc_Vec2_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec2) + +static bool js_new_cc_Vec2__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec2 *result; + result = (cc::Vec2 *)new cc::Vec2(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec2 *)new cc::Vec2(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec2 *)new cc::Vec2((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec2 *arg1 = 0 ; + cc::Vec2 *arg2 = 0 ; + cc::Vec2 temp1 ; + cc::Vec2 temp2 ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Vec2 *)new cc::Vec2((cc::Vec2 const &)*arg1,(cc::Vec2 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec2 *arg1 = 0 ; + cc::Vec2 temp1 ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Vec2 *)new cc::Vec2((cc::Vec2 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Vec2__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec2__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec2__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec2__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec2__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec2"); + return false; +} +SE_BIND_CTOR(js_new_cc_Vec2, __jsb_cc_Vec2_class, js_delete_cc_Vec2) + +static bool js_delete_cc_Vec2(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec2) + +bool js_register_cc_Vec2(se::Object* obj) { + auto* cls = se::Class::create("Vec2", obj, nullptr, _SE(js_new_cc_Vec2)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Vec2)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Vec2_proto = cls->getProto(); + __jsb_cc_Vec2_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Color_class = nullptr; +se::Object* __jsb_cc_Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Color) + +static bool js_new_cc_Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Color *result; + result = (cc::Color *)new cc::Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint8_t arg1 ; + uint8_t arg2 ; + uint8_t arg3 ; + uint8_t arg4 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Color *)new cc::Color(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint8_t *arg1 = (uint8_t *) NULL ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Color *)new cc::Color((uint8_t const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint32_t arg1 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Color *)new cc::Color(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Color *arg1 = 0 ; + cc::Color *arg2 = 0 ; + cc::Color temp1 ; + cc::Color temp2 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Color *)new cc::Color((cc::Color const &)*arg1,(cc::Color const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Color *arg1 = 0 ; + cc::Color temp1 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Color *)new cc::Color((cc::Color const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Color__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_Color__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Color__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Color__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Color__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Color__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Color"); + return false; +} +SE_BIND_CTOR(js_new_cc_Color, __jsb_cc_Color_class, js_delete_cc_Color) + +static bool js_delete_cc_Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Color) + +bool js_register_cc_Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_cc_Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Color_proto = cls->getProto(); + __jsb_cc_Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Vec3_class = nullptr; +se::Object* __jsb_cc_Vec3_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec3) + +static bool js_new_cc_Vec3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *result; + result = (cc::Vec3 *)new cc::Vec3(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec3 *)new cc::Vec3(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec3 *)new cc::Vec3((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp1 ; + cc::Vec3 temp2 ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Vec3 *)new cc::Vec3((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + cc::Vec3 temp1 ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Vec3 *)new cc::Vec3((cc::Vec3 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Vec3__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_Vec3__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec3__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec3__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec3__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec3"); + return false; +} +SE_BIND_CTOR(js_new_cc_Vec3, __jsb_cc_Vec3_class, js_delete_cc_Vec3) + +static bool js_delete_cc_Vec3(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec3) + +bool js_register_cc_Vec3(se::Object* obj) { + auto* cls = se::Class::create("Vec3", obj, nullptr, _SE(js_new_cc_Vec3)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Vec3)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Vec3_proto = cls->getProto(); + __jsb_cc_Vec3_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Vec4_class = nullptr; +se::Object* __jsb_cc_Vec4_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec4) + +static bool js_new_cc_Vec4__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec4 *result; + result = (cc::Vec4 *)new cc::Vec4(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec4 *)new cc::Vec4(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec4 *)new cc::Vec4((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec4 *arg1 = 0 ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp1 ; + cc::Vec4 temp2 ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Vec4 *)new cc::Vec4((cc::Vec4 const &)*arg1,(cc::Vec4 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec4 *arg1 = 0 ; + cc::Vec4 temp1 ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Vec4 *)new cc::Vec4((cc::Vec4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Vec4__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_Vec4__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec4__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec4__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec4__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec4"); + return false; +} +SE_BIND_CTOR(js_new_cc_Vec4, __jsb_cc_Vec4_class, js_delete_cc_Vec4) + +static bool js_delete_cc_Vec4(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec4) + +bool js_register_cc_Vec4(se::Object* obj) { + auto* cls = se::Class::create("Vec4", obj, nullptr, _SE(js_new_cc_Vec4)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Vec4)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Vec4_proto = cls->getProto(); + __jsb_cc_Vec4_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mat3_class = nullptr; +se::Object* __jsb_cc_Mat3_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mat3) + +static bool js_new_cc_Mat3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat3 *result; + result = (cc::Mat3 *)new cc::Mat3(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat3 *)new cc::Mat3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat3 *)new cc::Mat3((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat3 *arg1 = 0 ; + cc::Mat3 temp1 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat3 *)new cc::Mat3((cc::Mat3 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *arg1 = 0 ; + cc::Mat4 temp1 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat3 *)new cc::Mat3((cc::Mat4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Quaternion *arg1 = 0 ; + cc::Quaternion temp1 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat3 *)new cc::Mat3((cc::Quaternion const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Mat3__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 9) { + ret = js_new_cc_Mat3__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat3"); + return false; +} +SE_BIND_CTOR(js_new_cc_Mat3, __jsb_cc_Mat3_class, js_delete_cc_Mat3) + +static bool js_delete_cc_Mat3(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mat3) + +bool js_register_cc_Mat3(se::Object* obj) { + auto* cls = se::Class::create("Mat3", obj, nullptr, _SE(js_new_cc_Mat3)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mat3)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mat3_proto = cls->getProto(); + __jsb_cc_Mat3_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mat4_class = nullptr; +se::Object* __jsb_cc_Mat4_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mat4) + +static bool js_new_cc_Mat4__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *result; + result = (cc::Mat4 *)new cc::Mat4(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + float arg10 ; + float arg11 ; + float arg12 ; + float arg13 ; + float arg14 ; + float arg15 ; + float arg16 ; + cc::Mat4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &arg11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[11], &arg12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[12], &arg13, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[13], &arg14, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[14], &arg15, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[15], &arg16, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat4 *)new cc::Mat4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Mat4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat4 *)new cc::Mat4((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *arg1 = 0 ; + cc::Mat4 temp1 ; + cc::Mat4 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat4 *)new cc::Mat4((cc::Mat4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Mat4__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 16) { + ret = js_new_cc_Mat4__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat4__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat4__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat4"); + return false; +} +SE_BIND_CTOR(js_new_cc_Mat4, __jsb_cc_Mat4_class, js_delete_cc_Mat4) + +static bool js_delete_cc_Mat4(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mat4) + +bool js_register_cc_Mat4(se::Object* obj) { + auto* cls = se::Class::create("Mat4", obj, nullptr, _SE(js_new_cc_Mat4)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mat4)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mat4_proto = cls->getProto(); + __jsb_cc_Mat4_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Quaternion_class = nullptr; +se::Object* __jsb_cc_Quaternion_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Quaternion) + +static bool js_new_cc_Quaternion__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Quaternion *result; + result = (cc::Quaternion *)new cc::Quaternion(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Quaternion *)new cc::Quaternion(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Quaternion *)new cc::Quaternion(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *arg1 = 0 ; + cc::Mat4 temp1 ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Quaternion *)new cc::Quaternion((cc::Mat4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + float arg2 ; + cc::Vec3 temp1 ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Quaternion *)new cc::Quaternion((cc::Vec3 const &)*arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Quaternion__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_Quaternion__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Quaternion__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Quaternion__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Quaternion__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Quat"); + return false; +} +SE_BIND_CTOR(js_new_cc_Quaternion, __jsb_cc_Quaternion_class, js_delete_cc_Quaternion) + +static bool js_delete_cc_Quaternion(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Quaternion) + +bool js_register_cc_Quaternion(se::Object* obj) { + auto* cls = se::Class::create("Quat", obj, nullptr, _SE(js_new_cc_Quaternion)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Quaternion)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Quaternion_proto = cls->getProto(); + __jsb_cc_Quaternion_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CCObject_class = nullptr; +se::Object* __jsb_cc_CCObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CCObject) + +static bool js_cc_CCObject_deferredDestroy_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::CCObject::deferredDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject_deferredDestroy_static) + +static bool js_new_cc_CCObject__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string arg1 ; + cc::CCObject *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::CCObject *)new cc::CCObject(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_CCObject__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::CCObject *result; + result = (cc::CCObject *)new cc::CCObject(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_CCObject(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_cc_CCObject__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_CCObject__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of CCObject"); + return false; +} +SE_BIND_CTOR(js_new_cc_CCObject, __jsb_cc_CCObject_class, js_delete_cc_CCObject) + +static bool js_delete_cc_CCObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CCObject) + +static bool js_cc_CCObject_destruct(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destruct(); + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject_destruct) + +static bool js_cc_CCObject__destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) 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(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_CCObject__destroy) + +static bool js_cc_CCObject__destroyImmediate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyImmediate(); + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject__destroyImmediate) + +static bool js_cc_CCObject_toString(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::CCObject const *)arg1)->toString(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject_toString) + +static bool js_cc_CCObject__objFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_objFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject__objFlags_set) + +static bool js_cc_CCObject__objFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_objFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_objFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CCObject__objFlags_get) + +static bool js_cc_CCObject__name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject__name_set) + +static bool js_cc_CCObject__name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CCObject__name_get) + +static bool js_cc_CCObject_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_CCObject_name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject_name_set) + +static bool js_cc_CCObject_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_CCObject_name_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_CCObject_name_get) + +static bool js_cc_CCObject_hideFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + cc::CCObject::Flags arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_CCObject_hideFlags_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject_hideFlags_set) + +static bool js_cc_CCObject_hideFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + cc::CCObject::Flags result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::CCObject::Flags)cc_CCObject_hideFlags_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_CCObject_hideFlags_get) + +static bool js_cc_CCObject_isValid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_CCObject_isValid_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CCObject_isValid_get) + +bool js_register_cc_CCObject(se::Object* obj) { + auto* cls = se::Class::create("CCObject", obj, nullptr, _SE(js_new_cc_CCObject)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_objFlags", _SE(js_cc_CCObject__objFlags_get), _SE(js_cc_CCObject__objFlags_set)); + cls->defineProperty("_name", _SE(js_cc_CCObject__name_get), _SE(js_cc_CCObject__name_set)); + cls->defineProperty("name", _SE(js_cc_CCObject_name_get), _SE(js_cc_CCObject_name_set)); + cls->defineProperty("hideFlags", _SE(js_cc_CCObject_hideFlags_get), _SE(js_cc_CCObject_hideFlags_set)); + cls->defineProperty("isValid", _SE(js_cc_CCObject_isValid_get), nullptr); + + cls->defineFunction("destruct", _SE(js_cc_CCObject_destruct)); + cls->defineFunction("_destroy", _SE(js_cc_CCObject__destroy)); + cls->defineFunction("_destroyImmediate", _SE(js_cc_CCObject__destroyImmediate)); + cls->defineFunction("toString", _SE(js_cc_CCObject_toString)); + + + cls->defineStaticFunction("deferredDestroy", _SE(js_cc_CCObject_deferredDestroy_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CCObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CCObject_proto = cls->getProto(); + __jsb_cc_CCObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_isObjectValid__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + bool arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::isObjectValid(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_isObjectValid__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::isObjectValid(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_isObjectValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_isObjectValid__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_isObjectValid__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_isObjectValid) + +se::Class* __jsb_cc_JSBNativeDataHolder_class = nullptr; +se::Object* __jsb_cc_JSBNativeDataHolder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_JSBNativeDataHolder) + +static bool js_new_cc_JSBNativeDataHolder__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::JSBNativeDataHolder *result; + result = (cc::JSBNativeDataHolder *)new cc::JSBNativeDataHolder(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_JSBNativeDataHolder__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint8_t *arg1 = (uint8_t *) NULL ; + cc::JSBNativeDataHolder *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::JSBNativeDataHolder *)new cc::JSBNativeDataHolder(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_JSBNativeDataHolder(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_JSBNativeDataHolder__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_JSBNativeDataHolder__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of JSBNativeDataHolder"); + return false; +} +SE_BIND_CTOR(js_new_cc_JSBNativeDataHolder, __jsb_cc_JSBNativeDataHolder_class, js_delete_cc_JSBNativeDataHolder) + +static bool js_delete_cc_JSBNativeDataHolder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_JSBNativeDataHolder) + +static bool js_cc_JSBNativeDataHolder_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::JSBNativeDataHolder *arg1 = (cc::JSBNativeDataHolder *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_JSBNativeDataHolder_destroy) + +bool js_register_cc_JSBNativeDataHolder(se::Object* obj) { + auto* cls = se::Class::create("JSBNativeDataHolder", obj, nullptr, _SE(js_new_cc_JSBNativeDataHolder)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_JSBNativeDataHolder_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_JSBNativeDataHolder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_JSBNativeDataHolder_proto = cls->getProto(); + __jsb_cc_JSBNativeDataHolder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICanvasGradient_class = nullptr; +se::Object* __jsb_cc_ICanvasGradient_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICanvasGradient) + +static bool js_delete_cc_ICanvasGradient(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICanvasGradient) + +static bool js_cc_ICanvasGradient_addColorStop(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasGradient *arg1 = (cc::ICanvasGradient *) NULL ; + float arg2 ; + ccstd::string *arg3 = 0 ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addColorStop(arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasGradient_addColorStop) + +bool js_register_cc_ICanvasGradient(se::Object* obj) { + auto* cls = se::Class::create("ICanvasGradient", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addColorStop", _SE(js_cc_ICanvasGradient_addColorStop)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICanvasGradient)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICanvasGradient_proto = cls->getProto(); + __jsb_cc_ICanvasGradient_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICanvasRenderingContext2D_class = nullptr; +se::Object* __jsb_cc_ICanvasRenderingContext2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICanvasRenderingContext2D) + +static bool js_cc_ICanvasRenderingContext2D_rect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->rect(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_rect) + +static bool js_cc_ICanvasRenderingContext2D_clearRect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->clearRect(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_clearRect) + +static bool js_cc_ICanvasRenderingContext2D_createLinearGradient(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::ICanvasGradient *result = 0 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::ICanvasGradient *)(arg1)->createLinearGradient(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_createLinearGradient) + +static bool js_cc_ICanvasRenderingContext2D_save(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->save(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_save) + +static bool js_cc_ICanvasRenderingContext2D_beginPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginPath(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_beginPath) + +static bool js_cc_ICanvasRenderingContext2D_closePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->closePath(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_closePath) + +static bool js_cc_ICanvasRenderingContext2D_moveTo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->moveTo(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_moveTo) + +static bool js_cc_ICanvasRenderingContext2D_lineTo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->lineTo(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_lineTo) + +static bool js_cc_ICanvasRenderingContext2D_fill(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->fill(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fill) + +static bool js_cc_ICanvasRenderingContext2D_stroke(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stroke(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_stroke) + +static bool js_cc_ICanvasRenderingContext2D_restore(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->restore(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_restore) + +static bool js_cc_ICanvasRenderingContext2D_setShadowBlur(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowBlur(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowBlur) + +static bool js_cc_ICanvasRenderingContext2D_setShadowColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setShadowColor((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowColor) + +static bool js_cc_ICanvasRenderingContext2D_setShadowOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowOffsetX(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowOffsetX) + +static bool js_cc_ICanvasRenderingContext2D_setShadowOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowOffsetY(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowOffsetY) + +static bool js_cc_ICanvasRenderingContext2D_fillImageData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + cc::Data *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::Data temp2 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->fillImageData((cc::Data const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fillImageData) + +static bool js_cc_ICanvasRenderingContext2D_translate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->translate(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_translate) + +static bool js_cc_ICanvasRenderingContext2D_scale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->scale(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_scale) + +static bool js_cc_ICanvasRenderingContext2D_rotate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->rotate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_rotate) + +static bool js_cc_ICanvasRenderingContext2D_transform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->transform(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_transform) + +static bool js_cc_ICanvasRenderingContext2D_setTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTransform(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setTransform) + +static bool js_cc_ICanvasRenderingContext2D_fetchData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->fetchData(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fetchData) + +static bool js_cc_ICanvasRenderingContext2D_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_ICanvasRenderingContext2D_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_width_set) + +static bool js_cc_ICanvasRenderingContext2D_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_ICanvasRenderingContext2D_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_height_set) + +static bool js_cc_ICanvasRenderingContext2D_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_ICanvasRenderingContext2D_lineWidth_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineWidth_set) + +static bool js_cc_ICanvasRenderingContext2D_fillStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_fillStyle_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_fillStyle_set) + +static bool js_cc_ICanvasRenderingContext2D_font_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_font_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_font_set) + +static bool js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_globalCompositeOperation_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set) + +static bool js_cc_ICanvasRenderingContext2D_lineCap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_lineCap_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineCap_set) + +static bool js_cc_ICanvasRenderingContext2D_strokeStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_strokeStyle_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_strokeStyle_set) + +static bool js_cc_ICanvasRenderingContext2D_lineJoin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_lineJoin_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineJoin_set) + +static bool js_cc_ICanvasRenderingContext2D_textAlign_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_textAlign_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_textAlign_set) + +static bool js_cc_ICanvasRenderingContext2D_textBaseline_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_textBaseline_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_textBaseline_set) + +static bool js_delete_cc_ICanvasRenderingContext2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICanvasRenderingContext2D) + +bool js_register_cc_ICanvasRenderingContext2D(se::Object* obj) { + auto* cls = se::Class::create("ICanvasRenderingContext2D", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", nullptr, _SE(js_cc_ICanvasRenderingContext2D_width_set)); + cls->defineProperty("height", nullptr, _SE(js_cc_ICanvasRenderingContext2D_height_set)); + cls->defineProperty("lineWidth", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineWidth_set)); + cls->defineProperty("fillStyle", nullptr, _SE(js_cc_ICanvasRenderingContext2D_fillStyle_set)); + cls->defineProperty("font", nullptr, _SE(js_cc_ICanvasRenderingContext2D_font_set)); + cls->defineProperty("globalCompositeOperation", nullptr, _SE(js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set)); + cls->defineProperty("lineCap", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineCap_set)); + cls->defineProperty("strokeStyle", nullptr, _SE(js_cc_ICanvasRenderingContext2D_strokeStyle_set)); + cls->defineProperty("lineJoin", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineJoin_set)); + cls->defineProperty("textAlign", nullptr, _SE(js_cc_ICanvasRenderingContext2D_textAlign_set)); + cls->defineProperty("textBaseline", nullptr, _SE(js_cc_ICanvasRenderingContext2D_textBaseline_set)); + + cls->defineFunction("rect", _SE(js_cc_ICanvasRenderingContext2D_rect)); + cls->defineFunction("clearRect", _SE(js_cc_ICanvasRenderingContext2D_clearRect)); + cls->defineFunction("createLinearGradient", _SE(js_cc_ICanvasRenderingContext2D_createLinearGradient)); + cls->defineFunction("save", _SE(js_cc_ICanvasRenderingContext2D_save)); + cls->defineFunction("beginPath", _SE(js_cc_ICanvasRenderingContext2D_beginPath)); + cls->defineFunction("closePath", _SE(js_cc_ICanvasRenderingContext2D_closePath)); + cls->defineFunction("moveTo", _SE(js_cc_ICanvasRenderingContext2D_moveTo)); + cls->defineFunction("lineTo", _SE(js_cc_ICanvasRenderingContext2D_lineTo)); + cls->defineFunction("fill", _SE(js_cc_ICanvasRenderingContext2D_fill)); + cls->defineFunction("stroke", _SE(js_cc_ICanvasRenderingContext2D_stroke)); + cls->defineFunction("restore", _SE(js_cc_ICanvasRenderingContext2D_restore)); + cls->defineFunction("setShadowBlur", _SE(js_cc_ICanvasRenderingContext2D_setShadowBlur)); + cls->defineFunction("setShadowColor", _SE(js_cc_ICanvasRenderingContext2D_setShadowColor)); + cls->defineFunction("setShadowOffsetX", _SE(js_cc_ICanvasRenderingContext2D_setShadowOffsetX)); + cls->defineFunction("setShadowOffsetY", _SE(js_cc_ICanvasRenderingContext2D_setShadowOffsetY)); + cls->defineFunction("fillImageData", _SE(js_cc_ICanvasRenderingContext2D_fillImageData)); + cls->defineFunction("translate", _SE(js_cc_ICanvasRenderingContext2D_translate)); + cls->defineFunction("scale", _SE(js_cc_ICanvasRenderingContext2D_scale)); + cls->defineFunction("rotate", _SE(js_cc_ICanvasRenderingContext2D_rotate)); + cls->defineFunction("transform", _SE(js_cc_ICanvasRenderingContext2D_transform)); + cls->defineFunction("setTransform", _SE(js_cc_ICanvasRenderingContext2D_setTransform)); + cls->defineFunction("fetchData", _SE(js_cc_ICanvasRenderingContext2D_fetchData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICanvasRenderingContext2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICanvasRenderingContext2D_proto = cls->getProto(); + __jsb_cc_ICanvasRenderingContext2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CanvasGradient_class = nullptr; +se::Object* __jsb_cc_CanvasGradient_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CanvasGradient) + +static bool js_new_cc_CanvasGradient(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::CanvasGradient *result; + result = (cc::CanvasGradient *)new cc::CanvasGradient(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CanvasGradient, __jsb_cc_CanvasGradient_class, js_delete_cc_CanvasGradient) + +static bool js_delete_cc_CanvasGradient(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CanvasGradient) + +bool js_register_cc_CanvasGradient(se::Object* obj) { + auto* cls = se::Class::create("CanvasGradient", obj, __jsb_cc_ICanvasGradient_proto, _SE(js_new_cc_CanvasGradient)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CanvasGradient)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CanvasGradient_proto = cls->getProto(); + __jsb_cc_CanvasGradient_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CanvasRenderingContext2D_class = nullptr; +se::Object* __jsb_cc_CanvasRenderingContext2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CanvasRenderingContext2D) + +static bool js_new_cc_CanvasRenderingContext2D(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + float arg2 ; + cc::CanvasRenderingContext2D *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::CanvasRenderingContext2D *)new cc::CanvasRenderingContext2D(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CanvasRenderingContext2D, __jsb_cc_CanvasRenderingContext2D_class, js_delete_cc_CanvasRenderingContext2D) + +static bool js_delete_cc_CanvasRenderingContext2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CanvasRenderingContext2D) + +static bool js_cc_CanvasRenderingContext2D__width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__width_set) + +static bool js_cc_CanvasRenderingContext2D__width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__width_get) + +static bool js_cc_CanvasRenderingContext2D__height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__height_set) + +static bool js_cc_CanvasRenderingContext2D__height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__height_get) + +static bool js_cc_CanvasRenderingContext2D__lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineWidth_set) + +static bool js_cc_CanvasRenderingContext2D__lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lineWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineWidth_get) + +static bool js_cc_CanvasRenderingContext2D__lineJoin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lineJoin, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineJoin_set) + +static bool js_cc_CanvasRenderingContext2D__lineJoin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lineJoin, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_lineJoin, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineJoin_get) + +static bool js_cc_CanvasRenderingContext2D__lineCap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lineCap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineCap_set) + +static bool js_cc_CanvasRenderingContext2D__lineCap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lineCap, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_lineCap, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineCap_get) + +static bool js_cc_CanvasRenderingContext2D__font_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_font, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__font_set) + +static bool js_cc_CanvasRenderingContext2D__font_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_font, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_font, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__font_get) + +static bool js_cc_CanvasRenderingContext2D__textAlign_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_textAlign, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__textAlign_set) + +static bool js_cc_CanvasRenderingContext2D__textAlign_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_textAlign, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_textAlign, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__textAlign_get) + +static bool js_cc_CanvasRenderingContext2D__textBaseline_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_textBaseline, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__textBaseline_set) + +static bool js_cc_CanvasRenderingContext2D__textBaseline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_textBaseline, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_textBaseline, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__textBaseline_get) + +static bool js_cc_CanvasRenderingContext2D__fillStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fillStyle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__fillStyle_set) + +static bool js_cc_CanvasRenderingContext2D__fillStyle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fillStyle, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_fillStyle, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__fillStyle_get) + +static bool js_cc_CanvasRenderingContext2D__strokeStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_strokeStyle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__strokeStyle_set) + +static bool js_cc_CanvasRenderingContext2D__strokeStyle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_strokeStyle, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_strokeStyle, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__strokeStyle_get) + +static bool js_cc_CanvasRenderingContext2D__globalCompositeOperation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_globalCompositeOperation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__globalCompositeOperation_set) + +static bool js_cc_CanvasRenderingContext2D__globalCompositeOperation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_globalCompositeOperation, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_globalCompositeOperation, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__globalCompositeOperation_get) + +bool js_register_cc_CanvasRenderingContext2D(se::Object* obj) { + auto* cls = se::Class::create("CanvasRenderingContext2D", obj, __jsb_cc_ICanvasRenderingContext2D_proto, _SE(js_new_cc_CanvasRenderingContext2D)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_width", _SE(js_cc_CanvasRenderingContext2D__width_get), _SE(js_cc_CanvasRenderingContext2D__width_set)); + cls->defineProperty("_height", _SE(js_cc_CanvasRenderingContext2D__height_get), _SE(js_cc_CanvasRenderingContext2D__height_set)); + cls->defineProperty("_lineWidth", _SE(js_cc_CanvasRenderingContext2D__lineWidth_get), _SE(js_cc_CanvasRenderingContext2D__lineWidth_set)); + cls->defineProperty("_lineJoin", _SE(js_cc_CanvasRenderingContext2D__lineJoin_get), _SE(js_cc_CanvasRenderingContext2D__lineJoin_set)); + cls->defineProperty("_lineCap", _SE(js_cc_CanvasRenderingContext2D__lineCap_get), _SE(js_cc_CanvasRenderingContext2D__lineCap_set)); + cls->defineProperty("_font", _SE(js_cc_CanvasRenderingContext2D__font_get), _SE(js_cc_CanvasRenderingContext2D__font_set)); + cls->defineProperty("_textAlign", _SE(js_cc_CanvasRenderingContext2D__textAlign_get), _SE(js_cc_CanvasRenderingContext2D__textAlign_set)); + cls->defineProperty("_textBaseline", _SE(js_cc_CanvasRenderingContext2D__textBaseline_get), _SE(js_cc_CanvasRenderingContext2D__textBaseline_set)); + cls->defineProperty("_fillStyle", _SE(js_cc_CanvasRenderingContext2D__fillStyle_get), _SE(js_cc_CanvasRenderingContext2D__fillStyle_set)); + cls->defineProperty("_strokeStyle", _SE(js_cc_CanvasRenderingContext2D__strokeStyle_get), _SE(js_cc_CanvasRenderingContext2D__strokeStyle_set)); + cls->defineProperty("_globalCompositeOperation", _SE(js_cc_CanvasRenderingContext2D__globalCompositeOperation_get), _SE(js_cc_CanvasRenderingContext2D__globalCompositeOperation_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CanvasRenderingContext2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CanvasRenderingContext2D_proto = cls->getProto(); + __jsb_cc_CanvasRenderingContext2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Device_class = nullptr; +se::Object* __jsb_cc_Device_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Device) + +static bool js_cc_Device_getDPI_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (int)cc::Device::getDPI(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDPI_static) + +static bool js_cc_Device_getDevicePixelRatio_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::Device::getDevicePixelRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDevicePixelRatio_static) + +static bool js_cc_Device_setAccelerometerEnabled_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::Device::setAccelerometerEnabled(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_setAccelerometerEnabled_static) + +static bool js_cc_Device_setAccelerometerInterval_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::Device::setAccelerometerInterval(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_setAccelerometerInterval_static) + +static bool js_cc_Device_getDeviceOrientation_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IScreen::Orientation result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::IScreen::Orientation)cc::Device::getDeviceOrientation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDeviceOrientation_static) + +static bool js_cc_Device_getDeviceModel_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = cc::Device::getDeviceModel(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDeviceModel_static) + +static bool js_cc_Device_setKeepScreenOn_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::Device::setKeepScreenOn(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_setKeepScreenOn_static) + +static bool js_cc_Device_vibrate_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::Device::vibrate(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_vibrate_static) + +static bool js_cc_Device_getBatteryLevel_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::Device::getBatteryLevel(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getBatteryLevel_static) + +static bool js_cc_Device_getNetworkType_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::INetwork::NetworkType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::INetwork::NetworkType)cc::Device::getNetworkType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getNetworkType_static) + +static bool js_cc_Device_getSafeAreaEdge_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Vec4 result; + cc::Vec4 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = cc::Device::getSafeAreaEdge(); + + temp = ccnew cc::Vec4(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getSafeAreaEdge_static) + +static bool js_delete_cc_Device(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Device) + +bool js_register_cc_Device(se::Object* obj) { + auto* cls = se::Class::create("Device", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getDPI", _SE(js_cc_Device_getDPI_static)); + cls->defineStaticFunction("getDevicePixelRatio", _SE(js_cc_Device_getDevicePixelRatio_static)); + cls->defineStaticFunction("setAccelerometerEnabled", _SE(js_cc_Device_setAccelerometerEnabled_static)); + cls->defineStaticFunction("setAccelerometerInterval", _SE(js_cc_Device_setAccelerometerInterval_static)); + cls->defineStaticFunction("getDeviceOrientation", _SE(js_cc_Device_getDeviceOrientation_static)); + cls->defineStaticFunction("getDeviceModel", _SE(js_cc_Device_getDeviceModel_static)); + cls->defineStaticFunction("setKeepScreenOn", _SE(js_cc_Device_setKeepScreenOn_static)); + cls->defineStaticFunction("vibrate", _SE(js_cc_Device_vibrate_static)); + cls->defineStaticFunction("getBatteryLevel", _SE(js_cc_Device_getBatteryLevel_static)); + cls->defineStaticFunction("getNetworkType", _SE(js_cc_Device_getNetworkType_static)); + cls->defineStaticFunction("getSafeAreaEdge", _SE(js_cc_Device_getSafeAreaEdge_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Device)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Device_proto = cls->getProto(); + __jsb_cc_Device_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISystemWindow_class = nullptr; +se::Object* __jsb_cc_ISystemWindow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindow) + +static bool js_cc_ISystemWindow_createWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + char *arg2 = (char *) NULL ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + int arg7 ; + ccstd::string temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->createWindow((char const *)arg2,arg3,arg4,arg5,arg6,arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_ISystemWindow_createWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + char *arg2 = (char *) NULL ; + int arg3 ; + int arg4 ; + int arg5 ; + ccstd::string temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + 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 = (bool)(arg1)->createWindow((char const *)arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_ISystemWindow_createWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_ISystemWindow_createWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_ISystemWindow_createWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_ISystemWindow_createWindow) + +static bool js_cc_ISystemWindow_getWindowId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ISystemWindow const *)arg1)->getWindowId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_getWindowId) + +static bool js_cc_ISystemWindow_closeWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->closeWindow(); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_closeWindow) + +static bool js_cc_ISystemWindow_getWindowHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + uintptr_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ISystemWindow const *)arg1)->getWindowHandle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_getWindowHandle) + +static bool js_cc_ISystemWindow_getViewSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + cc::ISystemWindow::Size result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ISystemWindow const *)arg1)->getViewSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_getViewSize) + +static bool js_cc_ISystemWindow_setViewSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setViewSize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_setViewSize) + +static bool js_cc_ISystemWindow_setCursorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCursorEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_setCursorEnabled) + +static bool js_delete_cc_ISystemWindow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindow) + +bool js_register_cc_ISystemWindow(se::Object* obj) { + auto* cls = se::Class::create("ISystemWindow", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("createWindow", _SE(js_cc_ISystemWindow_createWindow)); + cls->defineFunction("getWindowId", _SE(js_cc_ISystemWindow_getWindowId)); + cls->defineFunction("closeWindow", _SE(js_cc_ISystemWindow_closeWindow)); + cls->defineFunction("getWindowHandle", _SE(js_cc_ISystemWindow_getWindowHandle)); + cls->defineFunction("getViewSize", _SE(js_cc_ISystemWindow_getViewSize)); + cls->defineFunction("setViewSize", _SE(js_cc_ISystemWindow_setViewSize)); + cls->defineFunction("setCursorEnabled", _SE(js_cc_ISystemWindow_setCursorEnabled)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISystemWindow_proto = cls->getProto(); + __jsb_cc_ISystemWindow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISystemWindowInfo_class = nullptr; +se::Object* __jsb_cc_ISystemWindowInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindowInfo) + +static bool js_cc_ISystemWindowInfo_title_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->title, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_title_set) + +static bool js_cc_ISystemWindowInfo_title_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->title, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->title, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_title_get) + +static bool js_cc_ISystemWindowInfo_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_x_set) + +static bool js_cc_ISystemWindowInfo_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_x_get) + +static bool js_cc_ISystemWindowInfo_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_y_set) + +static bool js_cc_ISystemWindowInfo_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_y_get) + +static bool js_cc_ISystemWindowInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_width_set) + +static bool js_cc_ISystemWindowInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_width_get) + +static bool js_cc_ISystemWindowInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_height_set) + +static bool js_cc_ISystemWindowInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_height_get) + +static bool js_cc_ISystemWindowInfo_flags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_flags_set) + +static bool js_cc_ISystemWindowInfo_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_flags_get) + +static bool js_cc_ISystemWindowInfo_externalHandle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->externalHandle); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_externalHandle_set) + +static bool js_cc_ISystemWindowInfo_externalHandle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalHandle, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalHandle, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_externalHandle_get) + +static bool js_new_cc_ISystemWindowInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ISystemWindowInfo *result; + result = (cc::ISystemWindowInfo *)new cc::ISystemWindowInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ISystemWindowInfo, __jsb_cc_ISystemWindowInfo_class, js_delete_cc_ISystemWindowInfo) + +static bool js_delete_cc_ISystemWindowInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindowInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISystemWindowInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("title", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->title), ctx); + } + + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("flags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flags), ctx); + } + + + json->getProperty("externalHandle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalHandle), ctx); + } + + + return ok; +} + + +bool js_register_cc_ISystemWindowInfo(se::Object* obj) { + auto* cls = se::Class::create("ISystemWindowInfo", obj, nullptr, _SE(js_new_cc_ISystemWindowInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("title", _SE(js_cc_ISystemWindowInfo_title_get), _SE(js_cc_ISystemWindowInfo_title_set)); + cls->defineProperty("x", _SE(js_cc_ISystemWindowInfo_x_get), _SE(js_cc_ISystemWindowInfo_x_set)); + cls->defineProperty("y", _SE(js_cc_ISystemWindowInfo_y_get), _SE(js_cc_ISystemWindowInfo_y_set)); + cls->defineProperty("width", _SE(js_cc_ISystemWindowInfo_width_get), _SE(js_cc_ISystemWindowInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_ISystemWindowInfo_height_get), _SE(js_cc_ISystemWindowInfo_height_set)); + cls->defineProperty("flags", _SE(js_cc_ISystemWindowInfo_flags_get), _SE(js_cc_ISystemWindowInfo_flags_set)); + cls->defineProperty("externalHandle", _SE(js_cc_ISystemWindowInfo_externalHandle_get), _SE(js_cc_ISystemWindowInfo_externalHandle_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindowInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISystemWindowInfo_proto = cls->getProto(); + __jsb_cc_ISystemWindowInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISystemWindowManager_class = nullptr; +se::Object* __jsb_cc_ISystemWindowManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindowManager) + +static bool js_cc_ISystemWindowManager_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->init(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindowManager_init) + +static bool js_cc_ISystemWindowManager_processEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->processEvent(); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindowManager_processEvent) + +static bool js_cc_ISystemWindowManager_createWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + cc::ISystemWindowInfo *arg2 = 0 ; + cc::ISystemWindowInfo temp2 ; + cc::ISystemWindow *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(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::ISystemWindow *)(arg1)->createWindow((cc::ISystemWindowInfo 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_ISystemWindowManager_createWindow) + +static bool js_cc_ISystemWindowManager_getWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + uint32_t arg2 ; + cc::ISystemWindow *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::ISystemWindow *)((cc::ISystemWindowManager const *)arg1)->getWindow(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_ISystemWindowManager_getWindow) + +static bool js_cc_ISystemWindowManager_getWindows(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + cc::SystemWindowMap *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(s); + if (nullptr == arg1) return true; + result = (cc::SystemWindowMap *) &((cc::ISystemWindowManager const *)arg1)->getWindows(); + + 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_ISystemWindowManager_getWindows) + +static bool js_delete_cc_ISystemWindowManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindowManager) + +bool js_register_cc_ISystemWindowManager(se::Object* obj) { + auto* cls = se::Class::create("ISystemWindowManager", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("init", _SE(js_cc_ISystemWindowManager_init)); + cls->defineFunction("processEvent", _SE(js_cc_ISystemWindowManager_processEvent)); + cls->defineFunction("createWindow", _SE(js_cc_ISystemWindowManager_createWindow)); + cls->defineFunction("getWindow", _SE(js_cc_ISystemWindowManager_getWindow)); + cls->defineFunction("getWindows", _SE(js_cc_ISystemWindowManager_getWindows)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindowManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISystemWindowManager_proto = cls->getProto(); + __jsb_cc_ISystemWindowManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_FileUtils_class = nullptr; +se::Object* __jsb_cc_FileUtils_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_FileUtils) + +static bool js_cc_FileUtils_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::FileUtils *)cc::FileUtils::getInstance(); + + 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_FileUtils_getInstance_static) + +static bool js_delete_cc_FileUtils(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_FileUtils) + +static bool js_cc_FileUtils_purgeCachedEntries(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->purgeCachedEntries(); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_purgeCachedEntries) + +static bool js_cc_FileUtils_getStringFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getStringFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getStringFromFile) + +static bool js_cc_FileUtils_getDataFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Data result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getDataFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getDataFromFile) + +static bool js_cc_FileUtils_getFileDataFromZip(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + uint32_t *arg4 = (uint32_t *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + unsigned char *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (unsigned char *)(arg1)->getFileDataFromZip((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileDataFromZip) + +static bool js_cc_FileUtils_fullPathForFilename(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->fullPathForFilename((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_fullPathForFilename) + +static bool js_cc_FileUtils_fullPathFromRelativeFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + ccstd::string result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (arg1)->fullPathFromRelativeFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_fullPathFromRelativeFile) + +static bool js_cc_FileUtils_setSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::vector< ccstd::string > *arg2 = 0 ; + ccstd::vector< ccstd::string > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSearchPaths((ccstd::vector< ccstd::string > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_setSearchPaths) + +static bool js_cc_FileUtils_getDefaultResourceRootPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *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(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &((cc::FileUtils const *)arg1)->getDefaultResourceRootPath(); + + 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_FileUtils_getDefaultResourceRootPath) + +static bool js_cc_FileUtils_setDefaultResourceRootPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDefaultResourceRootPath((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_setDefaultResourceRootPath) + +static bool js_cc_FileUtils_addSearchPath__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + bool arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSearchPath((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_FileUtils_addSearchPath__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSearchPath((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_FileUtils_addSearchPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_FileUtils_addSearchPath__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_FileUtils_addSearchPath__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_FileUtils_addSearchPath) + +static bool js_cc_FileUtils_getSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::vector< ccstd::string > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &((cc::FileUtils const *)arg1)->getSearchPaths(); + + 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_FileUtils_getSearchPaths) + +static bool js_cc_FileUtils_getOriginalSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::vector< ccstd::string > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &((cc::FileUtils const *)arg1)->getOriginalSearchPaths(); + + 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_FileUtils_getOriginalSearchPaths) + +static bool js_cc_FileUtils_getWritablePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::FileUtils const *)arg1)->getWritablePath(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getWritablePath) + +static bool js_cc_FileUtils_setWritablePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setWritablePath((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_setWritablePath) + +static bool js_cc_FileUtils_getValueMapFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::ValueMap result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getValueMapFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getValueMapFromFile) + +static bool js_cc_FileUtils_getValueMapFromData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + char *arg2 = (char *) NULL ; + int arg3 ; + ccstd::string temp2 ; + cc::ValueMap result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getValueMapFromData((char const *)arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getValueMapFromData) + +static bool js_cc_FileUtils_writeToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::ValueMap *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::ValueMap temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeToFile((cc::ValueMap const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeToFile) + +static bool js_cc_FileUtils_writeStringToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeStringToFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeStringToFile) + +static bool js_cc_FileUtils_writeDataToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::Data *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::Data temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeDataToFile((cc::Data const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeDataToFile) + +static bool js_cc_FileUtils_writeValueMapToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::ValueMap *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::ValueMap temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeValueMapToFile((cc::ValueMap const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeValueMapToFile) + +static bool js_cc_FileUtils_writeValueVectorToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::ValueVector *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::ValueVector temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeValueVectorToFile((cc::ValueVector const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeValueVectorToFile) + +static bool js_cc_FileUtils_getSuitableFOpen(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->getSuitableFOpen((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getSuitableFOpen) + +static bool js_cc_FileUtils_getValueVectorFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::ValueVector result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getValueVectorFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getValueVectorFromFile) + +static bool js_cc_FileUtils_isFileExist(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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::FileUtils const *)arg1)->isFileExist((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_isFileExist) + +static bool js_cc_FileUtils_getFileExtension(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->getFileExtension((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileExtension) + +static bool js_cc_FileUtils_isAbsolutePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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::FileUtils const *)arg1)->isAbsolutePath((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_isAbsolutePath) + +static bool js_cc_FileUtils_isDirectoryExist(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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::FileUtils const *)arg1)->isDirectoryExist((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_isDirectoryExist) + +static bool js_cc_FileUtils_listFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::vector< ccstd::string > result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->listFiles((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_listFiles) + +static bool js_cc_FileUtils_createDirectory(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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)(arg1)->createDirectory((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_createDirectory) + +static bool js_cc_FileUtils_removeDirectory(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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)(arg1)->removeDirectory((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_removeDirectory) + +static bool js_cc_FileUtils_removeFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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)(arg1)->removeFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_removeFile) + +static bool js_cc_FileUtils_renameFile__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + ccstd::string temp4 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (bool)(arg1)->renameFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_FileUtils_renameFile__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->renameFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_FileUtils_renameFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_FileUtils_renameFile__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_FileUtils_renameFile__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_FileUtils_renameFile) + +static bool js_cc_FileUtils_getFileSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + long result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (long)(arg1)->getFileSize((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileSize) + +static bool js_cc_FileUtils_normalizePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->normalizePath((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_normalizePath) + +static bool js_cc_FileUtils_getFileDir(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->getFileDir((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileDir) + +bool js_register_cc_FileUtils(se::Object* obj) { + auto* cls = se::Class::create("FileUtils", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("purgeCachedEntries", _SE(js_cc_FileUtils_purgeCachedEntries)); + cls->defineFunction("getStringFromFile", _SE(js_cc_FileUtils_getStringFromFile)); + cls->defineFunction("getDataFromFile", _SE(js_cc_FileUtils_getDataFromFile)); + cls->defineFunction("getFileDataFromZip", _SE(js_cc_FileUtils_getFileDataFromZip)); + cls->defineFunction("fullPathForFilename", _SE(js_cc_FileUtils_fullPathForFilename)); + cls->defineFunction("fullPathFromRelativeFile", _SE(js_cc_FileUtils_fullPathFromRelativeFile)); + cls->defineFunction("setSearchPaths", _SE(js_cc_FileUtils_setSearchPaths)); + cls->defineFunction("getDefaultResourceRootPath", _SE(js_cc_FileUtils_getDefaultResourceRootPath)); + cls->defineFunction("setDefaultResourceRootPath", _SE(js_cc_FileUtils_setDefaultResourceRootPath)); + cls->defineFunction("addSearchPath", _SE(js_cc_FileUtils_addSearchPath)); + cls->defineFunction("getSearchPaths", _SE(js_cc_FileUtils_getSearchPaths)); + cls->defineFunction("getOriginalSearchPaths", _SE(js_cc_FileUtils_getOriginalSearchPaths)); + cls->defineFunction("getWritablePath", _SE(js_cc_FileUtils_getWritablePath)); + cls->defineFunction("setWritablePath", _SE(js_cc_FileUtils_setWritablePath)); + cls->defineFunction("getValueMapFromFile", _SE(js_cc_FileUtils_getValueMapFromFile)); + cls->defineFunction("getValueMapFromData", _SE(js_cc_FileUtils_getValueMapFromData)); + cls->defineFunction("writeToFile", _SE(js_cc_FileUtils_writeToFile)); + cls->defineFunction("writeStringToFile", _SE(js_cc_FileUtils_writeStringToFile)); + cls->defineFunction("writeDataToFile", _SE(js_cc_FileUtils_writeDataToFile)); + cls->defineFunction("writeValueMapToFile", _SE(js_cc_FileUtils_writeValueMapToFile)); + cls->defineFunction("writeValueVectorToFile", _SE(js_cc_FileUtils_writeValueVectorToFile)); + cls->defineFunction("getSuitableFOpen", _SE(js_cc_FileUtils_getSuitableFOpen)); + cls->defineFunction("getValueVectorFromFile", _SE(js_cc_FileUtils_getValueVectorFromFile)); + cls->defineFunction("isFileExist", _SE(js_cc_FileUtils_isFileExist)); + cls->defineFunction("getFileExtension", _SE(js_cc_FileUtils_getFileExtension)); + cls->defineFunction("isAbsolutePath", _SE(js_cc_FileUtils_isAbsolutePath)); + cls->defineFunction("isDirectoryExist", _SE(js_cc_FileUtils_isDirectoryExist)); + cls->defineFunction("listFiles", _SE(js_cc_FileUtils_listFiles)); + cls->defineFunction("createDirectory", _SE(js_cc_FileUtils_createDirectory)); + cls->defineFunction("removeDirectory", _SE(js_cc_FileUtils_removeDirectory)); + cls->defineFunction("removeFile", _SE(js_cc_FileUtils_removeFile)); + cls->defineFunction("renameFile", _SE(js_cc_FileUtils_renameFile)); + cls->defineFunction("getFileSize", _SE(js_cc_FileUtils_getFileSize)); + cls->defineFunction("normalizePath", _SE(js_cc_FileUtils_normalizePath)); + cls->defineFunction("getFileDir", _SE(js_cc_FileUtils_getFileDir)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_FileUtils_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_FileUtils)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_FileUtils_proto = cls->getProto(); + __jsb_cc_FileUtils_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_createFileUtils(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::FileUtils *)cc::createFileUtils(); + + 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_createFileUtils) + +se::Class* __jsb_cc_SAXParser_class = nullptr; +se::Object* __jsb_cc_SAXParser_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SAXParser) + +static bool js_new_cc_SAXParser(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SAXParser *result; + result = (cc::SAXParser *)new cc::SAXParser(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SAXParser, __jsb_cc_SAXParser_class, js_delete_cc_SAXParser) + +static bool js_delete_cc_SAXParser(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SAXParser) + +static bool js_cc_PlistParser_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SAXParser *arg1 = (cc::SAXParser *) NULL ; + char *arg2 = (char *) NULL ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + result = (bool)(arg1)->init((char const *)arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_PlistParser_init) + +static bool js_cc_PlistParser_parse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SAXParser *arg1 = (cc::SAXParser *) 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(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)(arg1)->parse((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_PlistParser_parse) + +bool js_register_cc_SAXParser(se::Object* obj) { + auto* cls = se::Class::create("PlistParser", obj, nullptr, _SE(js_new_cc_SAXParser)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("init", _SE(js_cc_PlistParser_init)); + cls->defineFunction("parse", _SE(js_cc_PlistParser_parse)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SAXParser)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SAXParser_proto = cls->getProto(); + __jsb_cc_SAXParser_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#if CC_USE_DEBUG_RENDERER + +se::Class* __jsb_cc_DebugTextInfo_class = nullptr; +se::Object* __jsb_cc_DebugTextInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DebugTextInfo) + +static bool js_new_cc_DebugTextInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DebugTextInfo *result; + result = (cc::DebugTextInfo *)new cc::DebugTextInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DebugTextInfo, __jsb_cc_DebugTextInfo_class, js_delete_cc_DebugTextInfo) + +static bool js_cc_DebugTextInfo_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_color_set) + +static bool js_cc_DebugTextInfo_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_color_get) + +static bool js_cc_DebugTextInfo_bold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bold); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_bold_set) + +static bool js_cc_DebugTextInfo_bold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bold, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_bold_get) + +static bool js_cc_DebugTextInfo_italic_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->italic); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_italic_set) + +static bool js_cc_DebugTextInfo_italic_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->italic, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_italic_get) + +static bool js_cc_DebugTextInfo_shadow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadow); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadow_set) + +static bool js_cc_DebugTextInfo_shadow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadow, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadow_get) + +static bool js_cc_DebugTextInfo_shadowThickness_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadowThickness, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadowThickness_set) + +static bool js_cc_DebugTextInfo_shadowThickness_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadowThickness, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadowThickness_get) + +static bool js_cc_DebugTextInfo_shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadowColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadowColor_set) + +static bool js_cc_DebugTextInfo_shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadowColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shadowColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadowColor_get) + +static bool js_cc_DebugTextInfo_scale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_scale_set) + +static bool js_cc_DebugTextInfo_scale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_scale_get) + +static bool js_delete_cc_DebugTextInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DebugTextInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::DebugTextInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("color", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->color), ctx); + } + + + json->getProperty("bold", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bold), ctx); + } + + + json->getProperty("italic", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->italic), ctx); + } + + + json->getProperty("shadow", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadow), ctx); + } + + + json->getProperty("shadowThickness", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadowThickness), ctx); + } + + + json->getProperty("shadowColor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadowColor), ctx); + } + + + json->getProperty("scale", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->scale), ctx); + } + + + return ok; +} + + +bool js_register_cc_DebugTextInfo(se::Object* obj) { + auto* cls = se::Class::create("DebugTextInfo", obj, nullptr, _SE(js_new_cc_DebugTextInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("color", _SE(js_cc_DebugTextInfo_color_get), _SE(js_cc_DebugTextInfo_color_set)); + cls->defineProperty("bold", _SE(js_cc_DebugTextInfo_bold_get), _SE(js_cc_DebugTextInfo_bold_set)); + cls->defineProperty("italic", _SE(js_cc_DebugTextInfo_italic_get), _SE(js_cc_DebugTextInfo_italic_set)); + cls->defineProperty("shadow", _SE(js_cc_DebugTextInfo_shadow_get), _SE(js_cc_DebugTextInfo_shadow_set)); + cls->defineProperty("shadowThickness", _SE(js_cc_DebugTextInfo_shadowThickness_get), _SE(js_cc_DebugTextInfo_shadowThickness_set)); + cls->defineProperty("shadowColor", _SE(js_cc_DebugTextInfo_shadowColor_get), _SE(js_cc_DebugTextInfo_shadowColor_set)); + cls->defineProperty("scale", _SE(js_cc_DebugTextInfo_scale_get), _SE(js_cc_DebugTextInfo_scale_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DebugTextInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DebugTextInfo_proto = cls->getProto(); + __jsb_cc_DebugTextInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#endif // CC_USE_DEBUG_RENDERER +#if CC_USE_DEBUG_RENDERER + +se::Class* __jsb_cc_DebugRenderer_class = nullptr; +se::Object* __jsb_cc_DebugRenderer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DebugRenderer) + +static bool js_cc_DebugRenderer_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugRenderer *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::DebugRenderer *)cc::DebugRenderer::getInstance(); + + 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_DebugRenderer_getInstance_static) + +static bool js_new_cc_DebugRenderer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DebugRenderer *result; + result = (cc::DebugRenderer *)new cc::DebugRenderer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DebugRenderer, __jsb_cc_DebugRenderer_class, js_delete_cc_DebugRenderer) + +static bool js_delete_cc_DebugRenderer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DebugRenderer) + +static bool js_cc_DebugRenderer_addText__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::DebugRenderer *arg1 = (cc::DebugRenderer *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->addText((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3); + + + return true; +} + +static bool js_cc_DebugRenderer_addText__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::DebugRenderer *arg1 = (cc::DebugRenderer *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + cc::DebugTextInfo *arg4 = 0 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + cc::DebugTextInfo temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addText((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3,(cc::DebugTextInfo const &)*arg4); + + + return true; +} + +static bool js_cc_DebugRenderer_addText(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_DebugRenderer_addText__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_DebugRenderer_addText__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_DebugRenderer_addText) + +bool js_register_cc_DebugRenderer(se::Object* obj) { + auto* cls = se::Class::create("DebugRenderer", obj, nullptr, _SE(js_new_cc_DebugRenderer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addText", _SE(js_cc_DebugRenderer_addText)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_DebugRenderer_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DebugRenderer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DebugRenderer_proto = cls->getProto(); + __jsb_cc_DebugRenderer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#endif // CC_USE_DEBUG_RENDERER + + + +bool register_all_engine(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_Vec2(ns); + js_register_cc_Color(ns); + js_register_cc_Vec3(ns); + js_register_cc_Vec4(ns); + js_register_cc_Mat3(ns); + js_register_cc_Mat4(ns); + js_register_cc_Quaternion(ns); + js_register_cc_CCObject(ns); + js_register_cc_JSBNativeDataHolder(ns); + js_register_cc_ICanvasGradient(ns); + js_register_cc_ICanvasRenderingContext2D(ns); + js_register_cc_CanvasGradient(ns); + js_register_cc_CanvasRenderingContext2D(ns); + js_register_cc_Device(ns); + js_register_cc_ISystemWindow(ns); + js_register_cc_ISystemWindowInfo(ns); + js_register_cc_ISystemWindowManager(ns); + js_register_cc_FileUtils(ns); + js_register_cc_SAXParser(ns); +#if CC_USE_DEBUG_RENDERER + js_register_cc_DebugTextInfo(ns); +#endif // CC_USE_DEBUG_RENDERER +#if CC_USE_DEBUG_RENDERER + js_register_cc_DebugRenderer(ns); +#endif // CC_USE_DEBUG_RENDERER + + /* 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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_cocos_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_cocos_auto.h new file mode 100644 index 0000000000..a0e636f194 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_cocos_auto.h @@ -0,0 +1,176 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "core/data/Object.h" +#include "core/data/JSBNativeDataHolder.h" +#include "platform/interfaces/modules/canvas/CanvasRenderingContext2D.h" +#include "platform/interfaces/modules/Device.h" +#include "platform/interfaces/modules/ISystemWindow.h" +#include "platform/interfaces/modules/ISystemWindowManager.h" +#include "platform/FileUtils.h" +#include "platform/SAXParser.h" +#include "math/Vec2.h" +#include "math/Vec3.h" +#include "math/Vec4.h" +#include "math/Mat3.h" +#include "math/Mat4.h" +#include "math/Quaternion.h" +#include "math/Color.h" +#include "profiler/DebugRenderer.h" + + + +bool register_all_engine(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::Vec2); +extern se::Object *__jsb_cc_Vec2_proto; // NOLINT +extern se::Class * __jsb_cc_Vec2_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Color); +extern se::Object *__jsb_cc_Color_proto; // NOLINT +extern se::Class * __jsb_cc_Color_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Vec3); +extern se::Object *__jsb_cc_Vec3_proto; // NOLINT +extern se::Class * __jsb_cc_Vec3_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Vec4); +extern se::Object *__jsb_cc_Vec4_proto; // NOLINT +extern se::Class * __jsb_cc_Vec4_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Mat3); +extern se::Object *__jsb_cc_Mat3_proto; // NOLINT +extern se::Class * __jsb_cc_Mat3_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Mat4); +extern se::Object *__jsb_cc_Mat4_proto; // NOLINT +extern se::Class * __jsb_cc_Mat4_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Quaternion); +extern se::Object *__jsb_cc_Quaternion_proto; // NOLINT +extern se::Class * __jsb_cc_Quaternion_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CCObject); +extern se::Object *__jsb_cc_CCObject_proto; // NOLINT +extern se::Class * __jsb_cc_CCObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::JSBNativeDataHolder); +extern se::Object *__jsb_cc_JSBNativeDataHolder_proto; // NOLINT +extern se::Class * __jsb_cc_JSBNativeDataHolder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ICanvasGradient); +extern se::Object *__jsb_cc_ICanvasGradient_proto; // NOLINT +extern se::Class * __jsb_cc_ICanvasGradient_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ICanvasRenderingContext2D); +extern se::Object *__jsb_cc_ICanvasRenderingContext2D_proto; // NOLINT +extern se::Class * __jsb_cc_ICanvasRenderingContext2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CanvasGradient); +extern se::Object *__jsb_cc_CanvasGradient_proto; // NOLINT +extern se::Class * __jsb_cc_CanvasGradient_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CanvasRenderingContext2D); +extern se::Object *__jsb_cc_CanvasRenderingContext2D_proto; // NOLINT +extern se::Class * __jsb_cc_CanvasRenderingContext2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Device); +extern se::Object *__jsb_cc_Device_proto; // NOLINT +extern se::Class * __jsb_cc_Device_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ISystemWindow); +extern se::Object *__jsb_cc_ISystemWindow_proto; // NOLINT +extern se::Class * __jsb_cc_ISystemWindow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ISystemWindowInfo); +extern se::Object *__jsb_cc_ISystemWindowInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ISystemWindowInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISystemWindowInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ISystemWindowManager); +extern se::Object *__jsb_cc_ISystemWindowManager_proto; // NOLINT +extern se::Class * __jsb_cc_ISystemWindowManager_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::FileUtils); +extern se::Object *__jsb_cc_FileUtils_proto; // NOLINT +extern se::Class * __jsb_cc_FileUtils_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SAXParser); +extern se::Object *__jsb_cc_SAXParser_proto; // NOLINT +extern se::Class * __jsb_cc_SAXParser_class; // NOLINT + +#if CC_USE_DEBUG_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::DebugTextInfo); +extern se::Object *__jsb_cc_DebugTextInfo_proto; // NOLINT +extern se::Class * __jsb_cc_DebugTextInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::DebugTextInfo * to, se::Object *ctx); + +#endif // CC_USE_DEBUG_RENDERER +#if CC_USE_DEBUG_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::DebugRenderer); +extern se::Object *__jsb_cc_DebugRenderer_proto; // NOLINT +extern se::Class * __jsb_cc_DebugRenderer_class; // NOLINT + +#endif // CC_USE_DEBUG_RENDERER +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_dragonbones_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_dragonbones_auto.cpp new file mode 100644 index 0000000000..1a35380f30 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_dragonbones_auto.cpp @@ -0,0 +1,13634 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_2d_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_dragonbones_auto.h" + + + +se::Class* __jsb_dragonBones_Rectangle_class = nullptr; +se::Object* __jsb_dragonBones_Rectangle_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Rectangle) + +static bool js_dragonBones_Rectangle_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_x_set) + +static bool js_dragonBones_Rectangle_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_x_get) + +static bool js_dragonBones_Rectangle_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_y_set) + +static bool js_dragonBones_Rectangle_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_y_get) + +static bool js_dragonBones_Rectangle_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_width_set) + +static bool js_dragonBones_Rectangle_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_width_get) + +static bool js_dragonBones_Rectangle_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_height_set) + +static bool js_dragonBones_Rectangle_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_height_get) + +static bool js_new_dragonBones_Rectangle__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + dragonBones::Rectangle *result; + result = (dragonBones::Rectangle *)new dragonBones::Rectangle(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_dragonBones_Rectangle__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = 0 ; + dragonBones::Rectangle temp1 ; + dragonBones::Rectangle *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (dragonBones::Rectangle *)new dragonBones::Rectangle((dragonBones::Rectangle const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_dragonBones_Rectangle(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_dragonBones_Rectangle__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_dragonBones_Rectangle__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Rectangle"); + return false; +} +SE_BIND_CTOR(js_new_dragonBones_Rectangle, __jsb_dragonBones_Rectangle_class, js_delete_dragonBones_Rectangle) + +static bool js_delete_dragonBones_Rectangle(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Rectangle) + +static bool js_dragonBones_Rectangle_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Rectangle_clear) + +bool js_register_dragonBones_Rectangle(se::Object* obj) { + auto* cls = se::Class::create("Rectangle", obj, nullptr, _SE(js_new_dragonBones_Rectangle)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_dragonBones_Rectangle_x_get), _SE(js_dragonBones_Rectangle_x_set)); + cls->defineProperty("y", _SE(js_dragonBones_Rectangle_y_get), _SE(js_dragonBones_Rectangle_y_set)); + cls->defineProperty("width", _SE(js_dragonBones_Rectangle_width_get), _SE(js_dragonBones_Rectangle_width_set)); + cls->defineProperty("height", _SE(js_dragonBones_Rectangle_height_get), _SE(js_dragonBones_Rectangle_height_set)); + + cls->defineFunction("clear", _SE(js_dragonBones_Rectangle_clear)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Rectangle)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Rectangle_proto = cls->getProto(); + __jsb_dragonBones_Rectangle_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Transform_class = nullptr; +se::Object* __jsb_dragonBones_Transform_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Transform) + +static bool js_dragonBones_Transform_normalizeRadian_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)dragonBones::Transform::normalizeRadian(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Transform_normalizeRadian_static) + +static bool js_dragonBones_Transform_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_x_set) + +static bool js_dragonBones_Transform_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_x_get) + +static bool js_dragonBones_Transform_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_y_set) + +static bool js_dragonBones_Transform_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_y_get) + +static bool js_dragonBones_Transform_skew_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->skew, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_skew_set) + +static bool js_dragonBones_Transform_skew_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->skew, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_skew_get) + +static bool js_dragonBones_Transform_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rotation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_rotation_set) + +static bool js_dragonBones_Transform_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rotation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_rotation_get) + +static bool js_dragonBones_Transform_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scaleX, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_scaleX_set) + +static bool js_dragonBones_Transform_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scaleX, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_scaleX_get) + +static bool js_dragonBones_Transform_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scaleY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_scaleY_set) + +static bool js_dragonBones_Transform_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scaleY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_scaleY_get) + +static bool js_delete_dragonBones_Transform(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Transform) + +bool js_register_dragonBones_Transform(se::Object* obj) { + auto* cls = se::Class::create("Transform", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_dragonBones_Transform_x_get), _SE(js_dragonBones_Transform_x_set)); + cls->defineProperty("y", _SE(js_dragonBones_Transform_y_get), _SE(js_dragonBones_Transform_y_set)); + cls->defineProperty("skew", _SE(js_dragonBones_Transform_skew_get), _SE(js_dragonBones_Transform_skew_set)); + cls->defineProperty("rotation", _SE(js_dragonBones_Transform_rotation_get), _SE(js_dragonBones_Transform_rotation_set)); + cls->defineProperty("scaleX", _SE(js_dragonBones_Transform_scaleX_get), _SE(js_dragonBones_Transform_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_dragonBones_Transform_scaleY_get), _SE(js_dragonBones_Transform_scaleY_set)); + + + + cls->defineStaticFunction("normalizeRadian", _SE(js_dragonBones_Transform_normalizeRadian_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Transform)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Transform_proto = cls->getProto(); + __jsb_dragonBones_Transform_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Matrix_class = nullptr; +se::Object* __jsb_dragonBones_Matrix_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Matrix) + +static bool js_dragonBones_Matrix_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_a_set) + +static bool js_dragonBones_Matrix_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_a_get) + +static bool js_dragonBones_Matrix_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_b_set) + +static bool js_dragonBones_Matrix_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_b_get) + +static bool js_dragonBones_Matrix_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_c_set) + +static bool js_dragonBones_Matrix_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_c_get) + +static bool js_dragonBones_Matrix_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->d, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_d_set) + +static bool js_dragonBones_Matrix_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->d, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_d_get) + +static bool js_dragonBones_Matrix_tx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tx, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_tx_set) + +static bool js_dragonBones_Matrix_tx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tx, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_tx_get) + +static bool js_dragonBones_Matrix_ty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ty, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_ty_set) + +static bool js_dragonBones_Matrix_ty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_ty_get) + +static bool js_delete_dragonBones_Matrix(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Matrix) + +bool js_register_dragonBones_Matrix(se::Object* obj) { + auto* cls = se::Class::create("Matrix", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("a", _SE(js_dragonBones_Matrix_a_get), _SE(js_dragonBones_Matrix_a_set)); + cls->defineProperty("b", _SE(js_dragonBones_Matrix_b_get), _SE(js_dragonBones_Matrix_b_set)); + cls->defineProperty("c", _SE(js_dragonBones_Matrix_c_get), _SE(js_dragonBones_Matrix_c_set)); + cls->defineProperty("d", _SE(js_dragonBones_Matrix_d_get), _SE(js_dragonBones_Matrix_d_set)); + cls->defineProperty("tx", _SE(js_dragonBones_Matrix_tx_get), _SE(js_dragonBones_Matrix_tx_set)); + cls->defineProperty("ty", _SE(js_dragonBones_Matrix_ty_get), _SE(js_dragonBones_Matrix_ty_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Matrix)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Matrix_proto = cls->getProto(); + __jsb_dragonBones_Matrix_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BaseObject_class = nullptr; +se::Object* __jsb_dragonBones_BaseObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BaseObject) + +static bool js_dragonBones_BaseObject_setMaxCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::size_t arg1 ; + unsigned int arg2 ; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + dragonBones::BaseObject::setMaxCount(SWIG_STD_MOVE(arg1),arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseObject_setMaxCount_static) + +static bool js_dragonBones_BaseObject_clearPool_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::size_t arg1 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + dragonBones::BaseObject::clearPool(SWIG_STD_MOVE(arg1)); + + + return true; +} + +static bool js_dragonBones_BaseObject_clearPool_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + + dragonBones::BaseObject::clearPool(); + + + return true; +} + +static bool js_dragonBones_BaseObject_clearPool_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_dragonBones_BaseObject_clearPool_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_BaseObject_clearPool_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseObject_clearPool_static) + +static bool js_dragonBones_BaseObject_hashCode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BaseObject *arg1 = (dragonBones::BaseObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hashCode, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BaseObject_hashCode_get) + +static bool js_delete_dragonBones_BaseObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BaseObject) + +static bool js_dragonBones_BaseObject_returnToPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseObject *arg1 = (dragonBones::BaseObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->returnToPool(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseObject_returnToPool) + +bool js_register_dragonBones_BaseObject(se::Object* obj) { + auto* cls = se::Class::create("BaseObject", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hashCode", _SE(js_dragonBones_BaseObject_hashCode_get), nullptr); + + cls->defineFunction("returnToPool", _SE(js_dragonBones_BaseObject_returnToPool)); + + + cls->defineStaticFunction("setMaxCount", _SE(js_dragonBones_BaseObject_setMaxCount_static)); + cls->defineStaticFunction("clearPool", _SE(js_dragonBones_BaseObject_clearPool_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BaseObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BaseObject_proto = cls->getProto(); + __jsb_dragonBones_BaseObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_EventObject_class = nullptr; +se::Object* __jsb_dragonBones_EventObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_EventObject) + +static bool js_delete_dragonBones_EventObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_EventObject) + +static bool js_dragonBones_EventObject_time_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->time, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_time_set) + +static bool js_dragonBones_EventObject_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->time, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_time_get) + +static bool js_dragonBones_EventObject_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_type_set) + +static bool js_dragonBones_EventObject_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_type_get) + +static bool js_dragonBones_EventObject_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_name_set) + +static bool js_dragonBones_EventObject_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_name_get) + +static bool js_dragonBones_EventObject_armature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->armature, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_armature_set) + +static bool js_dragonBones_EventObject_armature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->armature, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->armature, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_armature_get) + +static bool js_dragonBones_EventObject_bone_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bone, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_bone_set) + +static bool js_dragonBones_EventObject_bone_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bone, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bone, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_bone_get) + +static bool js_dragonBones_EventObject_slot_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->slot, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_slot_set) + +static bool js_dragonBones_EventObject_slot_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->slot, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->slot, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_slot_get) + +static bool js_dragonBones_EventObject_animationState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->animationState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_animationState_set) + +static bool js_dragonBones_EventObject_animationState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->animationState, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->animationState, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_animationState_get) + +static bool js_dragonBones_EventObject_getArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::EventObject const *)arg1)->getArmature(); + + 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_dragonBones_EventObject_getArmature) + +static bool js_dragonBones_EventObject_getBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::Bone *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Bone *)((dragonBones::EventObject const *)arg1)->getBone(); + + 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_dragonBones_EventObject_getBone) + +static bool js_dragonBones_EventObject_getSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::Slot *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Slot *)((dragonBones::EventObject const *)arg1)->getSlot(); + + 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_dragonBones_EventObject_getSlot) + +static bool js_dragonBones_EventObject_getAnimationState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::AnimationState *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationState *)((dragonBones::EventObject const *)arg1)->getAnimationState(); + + 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_dragonBones_EventObject_getAnimationState) + +bool js_register_dragonBones_EventObject(se::Object* obj) { + auto* cls = se::Class::create("EventObject", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("time", _SE(js_dragonBones_EventObject_time_get), _SE(js_dragonBones_EventObject_time_set)); + cls->defineProperty("type", _SE(js_dragonBones_EventObject_type_get), _SE(js_dragonBones_EventObject_type_set)); + cls->defineProperty("name", _SE(js_dragonBones_EventObject_name_get), _SE(js_dragonBones_EventObject_name_set)); + cls->defineProperty("armature", _SE(js_dragonBones_EventObject_armature_get), _SE(js_dragonBones_EventObject_armature_set)); + cls->defineProperty("bone", _SE(js_dragonBones_EventObject_bone_get), _SE(js_dragonBones_EventObject_bone_set)); + cls->defineProperty("slot", _SE(js_dragonBones_EventObject_slot_get), _SE(js_dragonBones_EventObject_slot_set)); + cls->defineProperty("animationState", _SE(js_dragonBones_EventObject_animationState_get), _SE(js_dragonBones_EventObject_animationState_set)); + + cls->defineFunction("getArmature", _SE(js_dragonBones_EventObject_getArmature)); + cls->defineFunction("getBone", _SE(js_dragonBones_EventObject_getBone)); + cls->defineFunction("getSlot", _SE(js_dragonBones_EventObject_getSlot)); + cls->defineFunction("getAnimationState", _SE(js_dragonBones_EventObject_getAnimationState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_EventObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_EventObject_proto = cls->getProto(); + __jsb_dragonBones_EventObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BaseFactory_class = nullptr; +se::Object* __jsb_dragonBones_BaseFactory_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BaseFactory) + +static bool js_dragonBones_BaseFactory_autoSearch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->autoSearch); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BaseFactory_autoSearch_set) + +static bool js_dragonBones_BaseFactory_autoSearch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->autoSearch, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BaseFactory_autoSearch_get) + +static bool js_delete_dragonBones_BaseFactory(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BaseFactory) + +static bool js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + char *arg2 = (char *) NULL ; + std::string *arg3 = 0 ; + float arg4 ; + ccstd::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesData((char const *)arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + char *arg2 = (char *) NULL ; + std::string *arg3 = 0 ; + ccstd::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesData((char const *)arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + char *arg2 = (char *) NULL ; + ccstd::string temp2 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesData((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; +} + +static bool js_dragonBones_BaseFactory_parseDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_parseDragonBonesData) + +static bool js_dragonBones_BaseFactory_getDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::DragonBonesData *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(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 = (dragonBones::DragonBonesData *)((dragonBones::BaseFactory const *)arg1)->getDragonBonesData((std::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_dragonBones_BaseFactory_getDragonBonesData) + +static bool js_dragonBones_BaseFactory_addDragonBonesData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::DragonBonesData *arg2 = (dragonBones::DragonBonesData *) NULL ; + std::string *arg3 = 0 ; + std::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addDragonBonesData(arg2,(std::string const &)*arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addDragonBonesData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::DragonBonesData *arg2 = (dragonBones::DragonBonesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDragonBonesData(arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_addDragonBonesData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_addDragonBonesData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_addDragonBonesData) + +static bool js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesData((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesData((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_removeDragonBonesData) + +static bool js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::TextureAtlasData *arg2 = (dragonBones::TextureAtlasData *) NULL ; + std::string *arg3 = 0 ; + std::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTextureAtlasData(arg2,(std::string const &)*arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::TextureAtlasData *arg2 = (dragonBones::TextureAtlasData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTextureAtlasData(arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addTextureAtlasData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_addTextureAtlasData) + +static bool js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeTextureAtlasData((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeTextureAtlasData((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeTextureAtlasData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_removeTextureAtlasData) + +static bool js_dragonBones_BaseFactory_getArmatureData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::ArmatureData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::ArmatureData *)((dragonBones::BaseFactory const *)arg1)->getArmatureData((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_getArmatureData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureData *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::ArmatureData *)((dragonBones::BaseFactory const *)arg1)->getArmatureData((std::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; +} + +static bool js_dragonBones_BaseFactory_getArmatureData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_getArmatureData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_getArmatureData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_getArmatureData) + +static bool js_dragonBones_BaseFactory_clear__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->clear(arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_clear__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} + +static bool js_dragonBones_BaseFactory_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_dragonBones_BaseFactory_clear__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_BaseFactory_clear__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_clear) + +static bool js_dragonBones_BaseFactory_buildArmature__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_buildArmature__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::string const &)*arg2,(std::string const &)*arg3,(std::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_dragonBones_BaseFactory_buildArmature__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_buildArmature__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::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; +} + +static bool js_dragonBones_BaseFactory_buildArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_buildArmature) + +static bool js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + dragonBones::Slot *arg6 = (dragonBones::Slot *) NULL ; + int arg7 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceSlotDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + dragonBones::Slot *arg6 = (dragonBones::Slot *) NULL ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceSlotDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceSlotDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_replaceSlotDisplay) + +static bool js_dragonBones_BaseFactory_replaceSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::SkinData *arg3 = (dragonBones::SkinData *) NULL ; + bool arg4 ; + std::vector< std::string > *arg5 = 0 ; + std::vector< std::string > temp5 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceSkin(arg2,arg3,arg4,(std::vector< std::string > const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_replaceSkin) + +static bool js_dragonBones_BaseFactory_replaceAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::ArmatureData *arg3 = (dragonBones::ArmatureData *) NULL ; + bool arg4 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::ArmatureData *arg3 = (dragonBones::ArmatureData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(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 = (bool)((dragonBones::BaseFactory const *)arg1)->replaceAnimation(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_BaseFactory_replaceAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_BaseFactory_replaceAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_replaceAnimation) + +static bool js_dragonBones_BaseFactory_getClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::WorldClock *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::WorldClock *)((dragonBones::BaseFactory const *)arg1)->getClock(); + + 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_dragonBones_BaseFactory_getClock) + +static bool js_dragonBones_BaseFactory_changeSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::SkinData *arg3 = (dragonBones::SkinData *) NULL ; + std::vector< std::string > *arg4 = 0 ; + std::vector< std::string > temp4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((dragonBones::BaseFactory const *)arg1)->changeSkin(arg2,arg3,(std::vector< std::string > const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_changeSkin) + +bool js_register_dragonBones_BaseFactory(se::Object* obj) { + auto* cls = se::Class::create("BaseFactory", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("autoSearch", _SE(js_dragonBones_BaseFactory_autoSearch_get), _SE(js_dragonBones_BaseFactory_autoSearch_set)); + + cls->defineFunction("parseDragonBonesData", _SE(js_dragonBones_BaseFactory_parseDragonBonesData)); + cls->defineFunction("getDragonBonesData", _SE(js_dragonBones_BaseFactory_getDragonBonesData)); + cls->defineFunction("addDragonBonesData", _SE(js_dragonBones_BaseFactory_addDragonBonesData)); + cls->defineFunction("removeDragonBonesData", _SE(js_dragonBones_BaseFactory_removeDragonBonesData)); + cls->defineFunction("addTextureAtlasData", _SE(js_dragonBones_BaseFactory_addTextureAtlasData)); + cls->defineFunction("removeTextureAtlasData", _SE(js_dragonBones_BaseFactory_removeTextureAtlasData)); + cls->defineFunction("getArmatureData", _SE(js_dragonBones_BaseFactory_getArmatureData)); + cls->defineFunction("clear", _SE(js_dragonBones_BaseFactory_clear)); + cls->defineFunction("buildArmature", _SE(js_dragonBones_BaseFactory_buildArmature)); + cls->defineFunction("replaceSlotDisplay", _SE(js_dragonBones_BaseFactory_replaceSlotDisplay)); + cls->defineFunction("replaceSkin", _SE(js_dragonBones_BaseFactory_replaceSkin)); + cls->defineFunction("replaceAnimation", _SE(js_dragonBones_BaseFactory_replaceAnimation)); + cls->defineFunction("getClock", _SE(js_dragonBones_BaseFactory_getClock)); + cls->defineFunction("changeSkin", _SE(js_dragonBones_BaseFactory_changeSkin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BaseFactory)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BaseFactory_proto = cls->getProto(); + __jsb_dragonBones_BaseFactory_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BuildArmaturePackage_class = nullptr; +se::Object* __jsb_dragonBones_BuildArmaturePackage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BuildArmaturePackage) + +static bool js_dragonBones_BuildArmaturePackage_dataName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dataName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_dataName_set) + +static bool js_dragonBones_BuildArmaturePackage_dataName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dataName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dataName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_dataName_get) + +static bool js_dragonBones_BuildArmaturePackage_textureAtlasName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textureAtlasName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_textureAtlasName_set) + +static bool js_dragonBones_BuildArmaturePackage_textureAtlasName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textureAtlasName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textureAtlasName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_textureAtlasName_get) + +static bool js_dragonBones_BuildArmaturePackage_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_data_set) + +static bool js_dragonBones_BuildArmaturePackage_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_data_get) + +static bool js_dragonBones_BuildArmaturePackage_armature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->armature, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_armature_set) + +static bool js_dragonBones_BuildArmaturePackage_armature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->armature, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->armature, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_armature_get) + +static bool js_dragonBones_BuildArmaturePackage_skin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->skin, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_skin_set) + +static bool js_dragonBones_BuildArmaturePackage_skin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->skin, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->skin, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_skin_get) + +static bool js_new_dragonBones_BuildArmaturePackage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::BuildArmaturePackage *result; + result = (dragonBones::BuildArmaturePackage *)new dragonBones::BuildArmaturePackage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_BuildArmaturePackage, __jsb_dragonBones_BuildArmaturePackage_class, js_delete_dragonBones_BuildArmaturePackage) + +static bool js_delete_dragonBones_BuildArmaturePackage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BuildArmaturePackage) + +bool js_register_dragonBones_BuildArmaturePackage(se::Object* obj) { + auto* cls = se::Class::create("BuildArmaturePackage", obj, nullptr, _SE(js_new_dragonBones_BuildArmaturePackage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dataName", _SE(js_dragonBones_BuildArmaturePackage_dataName_get), _SE(js_dragonBones_BuildArmaturePackage_dataName_set)); + cls->defineProperty("textureAtlasName", _SE(js_dragonBones_BuildArmaturePackage_textureAtlasName_get), _SE(js_dragonBones_BuildArmaturePackage_textureAtlasName_set)); + cls->defineProperty("data", _SE(js_dragonBones_BuildArmaturePackage_data_get), _SE(js_dragonBones_BuildArmaturePackage_data_set)); + cls->defineProperty("armature", _SE(js_dragonBones_BuildArmaturePackage_armature_get), _SE(js_dragonBones_BuildArmaturePackage_armature_set)); + cls->defineProperty("skin", _SE(js_dragonBones_BuildArmaturePackage_skin_get), _SE(js_dragonBones_BuildArmaturePackage_skin_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BuildArmaturePackage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BuildArmaturePackage_proto = cls->getProto(); + __jsb_dragonBones_BuildArmaturePackage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_DragonBonesData_class = nullptr; +se::Object* __jsb_dragonBones_DragonBonesData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_DragonBonesData) + +static bool js_dragonBones_DragonBonesData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_DragonBonesData_name_set) + +static bool js_dragonBones_DragonBonesData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_DragonBonesData_name_get) + +static bool js_delete_dragonBones_DragonBonesData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_DragonBonesData) + +static bool js_dragonBones_DragonBonesData_addArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + dragonBones::ArmatureData *arg2 = (dragonBones::ArmatureData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArmature(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_DragonBonesData_addArmature) + +static bool js_dragonBones_DragonBonesData_getArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureData *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(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 = (dragonBones::ArmatureData *)((dragonBones::DragonBonesData const *)arg1)->getArmature((std::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_dragonBones_DragonBonesData_getArmature) + +static bool js_dragonBones_DragonBonesData_getFrameIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + std::vector< unsigned int > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< unsigned int > *)(arg1)->getFrameIndices(); + + 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_dragonBones_DragonBonesData_getFrameIndices) + +static bool js_dragonBones_DragonBonesData_getArmatureNames(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + std::vector< std::string > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< std::string > *) &((dragonBones::DragonBonesData const *)arg1)->getArmatureNames(); + + 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_dragonBones_DragonBonesData_getArmatureNames) + +bool js_register_dragonBones_DragonBonesData(se::Object* obj) { + auto* cls = se::Class::create("DragonBonesData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_dragonBones_DragonBonesData_name_get), _SE(js_dragonBones_DragonBonesData_name_set)); + + cls->defineFunction("addArmature", _SE(js_dragonBones_DragonBonesData_addArmature)); + cls->defineFunction("getArmature", _SE(js_dragonBones_DragonBonesData_getArmature)); + cls->defineFunction("getFrameIndices", _SE(js_dragonBones_DragonBonesData_getFrameIndices)); + cls->defineFunction("getArmatureNames", _SE(js_dragonBones_DragonBonesData_getArmatureNames)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_DragonBonesData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_DragonBonesData_proto = cls->getProto(); + __jsb_dragonBones_DragonBonesData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TextureAtlasData_class = nullptr; +se::Object* __jsb_dragonBones_TextureAtlasData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TextureAtlasData) + +static bool js_delete_dragonBones_TextureAtlasData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TextureAtlasData) + +static bool js_dragonBones_TextureAtlasData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TextureAtlasData_name_set) + +static bool js_dragonBones_TextureAtlasData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TextureAtlasData_name_get) + +static bool js_dragonBones_TextureAtlasData_createTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + dragonBones::TextureData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::TextureData *)((dragonBones::TextureAtlasData const *)arg1)->createTexture(); + + 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_dragonBones_TextureAtlasData_createTexture) + +static bool js_dragonBones_TextureAtlasData_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + dragonBones::TextureData *arg2 = (dragonBones::TextureData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TextureAtlasData_addTexture) + +static bool js_dragonBones_TextureAtlasData_getTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::TextureData *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(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 = (dragonBones::TextureData *)((dragonBones::TextureAtlasData const *)arg1)->getTexture((std::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_dragonBones_TextureAtlasData_getTexture) + +bool js_register_dragonBones_TextureAtlasData(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlasData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_dragonBones_TextureAtlasData_name_get), _SE(js_dragonBones_TextureAtlasData_name_set)); + + cls->defineFunction("createTexture", _SE(js_dragonBones_TextureAtlasData_createTexture)); + cls->defineFunction("addTexture", _SE(js_dragonBones_TextureAtlasData_addTexture)); + cls->defineFunction("getTexture", _SE(js_dragonBones_TextureAtlasData_getTexture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TextureAtlasData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TextureAtlasData_proto = cls->getProto(); + __jsb_dragonBones_TextureAtlasData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TextureData_class = nullptr; +se::Object* __jsb_dragonBones_TextureData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TextureData) + +static bool js_dragonBones_TextureData_createRectangle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::Rectangle *)dragonBones::TextureData::createRectangle(); + + 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_dragonBones_TextureData_createRectangle_static) + +static bool js_delete_dragonBones_TextureData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TextureData) + +static bool js_dragonBones_TextureData_getRegion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::Rectangle *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Rectangle *)(arg1)->getRegion(); + + 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_dragonBones_TextureData_getRegion) + +static bool js_dragonBones_TextureData_getFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::Rectangle *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Rectangle *)((dragonBones::TextureData const *)arg1)->getFrame(); + + 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_dragonBones_TextureData_getFrame) + +static bool js_dragonBones_TextureData_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::Rectangle *arg2 = (dragonBones::Rectangle *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TextureData_setFrame) + +static bool js_dragonBones_TextureData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::TextureAtlasData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::TextureAtlasData *)((dragonBones::TextureData const *)arg1)->getParent(); + + 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_dragonBones_TextureData_getParent) + +static bool js_dragonBones_TextureData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::TextureAtlasData *arg2 = (dragonBones::TextureAtlasData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TextureData_setParent) + +bool js_register_dragonBones_TextureData(se::Object* obj) { + auto* cls = se::Class::create("TextureData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getRegion", _SE(js_dragonBones_TextureData_getRegion)); + cls->defineFunction("getFrame", _SE(js_dragonBones_TextureData_getFrame)); + cls->defineFunction("setFrame", _SE(js_dragonBones_TextureData_setFrame)); + cls->defineFunction("getParent", _SE(js_dragonBones_TextureData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_TextureData_setParent)); + + + cls->defineStaticFunction("createRectangle", _SE(js_dragonBones_TextureData_createRectangle_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TextureData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TextureData_proto = cls->getProto(); + __jsb_dragonBones_TextureData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_ArmatureData_class = nullptr; +se::Object* __jsb_dragonBones_ArmatureData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_ArmatureData) + +static bool js_dragonBones_ArmatureData_frameRate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frameRate, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_ArmatureData_frameRate_set) + +static bool js_dragonBones_ArmatureData_frameRate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frameRate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_ArmatureData_frameRate_get) + +static bool js_dragonBones_ArmatureData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_ArmatureData_name_set) + +static bool js_dragonBones_ArmatureData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_ArmatureData_name_get) + +static bool js_delete_dragonBones_ArmatureData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_ArmatureData) + +static bool js_dragonBones_ArmatureData_sortBones(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->sortBones(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_sortBones) + +static bool js_dragonBones_ArmatureData_getBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::BoneData *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(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 = (dragonBones::BoneData *)((dragonBones::ArmatureData const *)arg1)->getBone((std::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_dragonBones_ArmatureData_getBone) + +static bool js_dragonBones_ArmatureData_getSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::SlotData *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(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 = (dragonBones::SlotData *)((dragonBones::ArmatureData const *)arg1)->getSlot((std::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_dragonBones_ArmatureData_getSlot) + +static bool js_dragonBones_ArmatureData_getSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::SkinData *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(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 = (dragonBones::SkinData *)((dragonBones::ArmatureData const *)arg1)->getSkin((std::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_dragonBones_ArmatureData_getSkin) + +static bool js_dragonBones_ArmatureData_getMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::MeshDisplayData *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::MeshDisplayData *)((dragonBones::ArmatureData const *)arg1)->getMesh((std::string const &)*arg2,(std::string const &)*arg3,(std::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; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_getMesh) + +static bool js_dragonBones_ArmatureData_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationData *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(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 = (dragonBones::AnimationData *)((dragonBones::ArmatureData const *)arg1)->getAnimation((std::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_dragonBones_ArmatureData_getAnimation) + +static bool js_dragonBones_ArmatureData_getType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::ArmatureData const *)arg1)->getType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_getType) + +static bool js_dragonBones_ArmatureData_setType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setType(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setType) + +static bool js_dragonBones_ArmatureData_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::Rectangle *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Rectangle *)(arg1)->getAABB(); + + 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_dragonBones_ArmatureData_getAABB) + +static bool js_dragonBones_ArmatureData_getAnimationNames(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::vector< std::string > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< std::string > *) &((dragonBones::ArmatureData const *)arg1)->getAnimationNames(); + + 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_dragonBones_ArmatureData_getAnimationNames) + +static bool js_dragonBones_ArmatureData_getDefaultSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::SkinData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::SkinData *)((dragonBones::ArmatureData const *)arg1)->getDefaultSkin(); + + 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_dragonBones_ArmatureData_getDefaultSkin) + +static bool js_dragonBones_ArmatureData_setDefaultSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::SkinData *arg2 = (dragonBones::SkinData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDefaultSkin(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setDefaultSkin) + +static bool js_dragonBones_ArmatureData_getDefaultAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::AnimationData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationData *)((dragonBones::ArmatureData const *)arg1)->getDefaultAnimation(); + + 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_dragonBones_ArmatureData_getDefaultAnimation) + +static bool js_dragonBones_ArmatureData_setDefaultAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::AnimationData *arg2 = (dragonBones::AnimationData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDefaultAnimation(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setDefaultAnimation) + +static bool js_dragonBones_ArmatureData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::DragonBonesData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::DragonBonesData *)((dragonBones::ArmatureData const *)arg1)->getParent(); + + 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_dragonBones_ArmatureData_getParent) + +static bool js_dragonBones_ArmatureData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::DragonBonesData *arg2 = (dragonBones::DragonBonesData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setParent) + +bool js_register_dragonBones_ArmatureData(se::Object* obj) { + auto* cls = se::Class::create("ArmatureData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frameRate", _SE(js_dragonBones_ArmatureData_frameRate_get), _SE(js_dragonBones_ArmatureData_frameRate_set)); + cls->defineProperty("name", _SE(js_dragonBones_ArmatureData_name_get), _SE(js_dragonBones_ArmatureData_name_set)); + + cls->defineFunction("sortBones", _SE(js_dragonBones_ArmatureData_sortBones)); + cls->defineFunction("getBone", _SE(js_dragonBones_ArmatureData_getBone)); + cls->defineFunction("getSlot", _SE(js_dragonBones_ArmatureData_getSlot)); + cls->defineFunction("getSkin", _SE(js_dragonBones_ArmatureData_getSkin)); + cls->defineFunction("getMesh", _SE(js_dragonBones_ArmatureData_getMesh)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_ArmatureData_getAnimation)); + cls->defineFunction("getType", _SE(js_dragonBones_ArmatureData_getType)); + cls->defineFunction("setType", _SE(js_dragonBones_ArmatureData_setType)); + cls->defineFunction("getAABB", _SE(js_dragonBones_ArmatureData_getAABB)); + cls->defineFunction("getAnimationNames", _SE(js_dragonBones_ArmatureData_getAnimationNames)); + cls->defineFunction("getDefaultSkin", _SE(js_dragonBones_ArmatureData_getDefaultSkin)); + cls->defineFunction("setDefaultSkin", _SE(js_dragonBones_ArmatureData_setDefaultSkin)); + cls->defineFunction("getDefaultAnimation", _SE(js_dragonBones_ArmatureData_getDefaultAnimation)); + cls->defineFunction("setDefaultAnimation", _SE(js_dragonBones_ArmatureData_setDefaultAnimation)); + cls->defineFunction("getParent", _SE(js_dragonBones_ArmatureData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_ArmatureData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_ArmatureData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_ArmatureData_proto = cls->getProto(); + __jsb_dragonBones_ArmatureData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BoneData_class = nullptr; +se::Object* __jsb_dragonBones_BoneData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BoneData) + +static bool js_dragonBones_BoneData_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->length, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BoneData_length_set) + +static bool js_dragonBones_BoneData_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->length, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BoneData_length_get) + +static bool js_dragonBones_BoneData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BoneData_name_set) + +static bool js_dragonBones_BoneData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BoneData_name_get) + +static bool js_dragonBones_BoneData_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BoneData_parent_set) + +static bool js_dragonBones_BoneData_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BoneData_parent_get) + +static bool js_delete_dragonBones_BoneData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BoneData) + +static bool js_dragonBones_BoneData_getTransfrom(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)(arg1)->getTransfrom(); + + 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_dragonBones_BoneData_getTransfrom) + +static bool js_dragonBones_BoneData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + dragonBones::BoneData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoneData *)((dragonBones::BoneData const *)arg1)->getParent(); + + 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_dragonBones_BoneData_getParent) + +static bool js_dragonBones_BoneData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + dragonBones::BoneData *arg2 = (dragonBones::BoneData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BoneData_setParent) + +bool js_register_dragonBones_BoneData(se::Object* obj) { + auto* cls = se::Class::create("BoneData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("length", _SE(js_dragonBones_BoneData_length_get), _SE(js_dragonBones_BoneData_length_set)); + cls->defineProperty("name", _SE(js_dragonBones_BoneData_name_get), _SE(js_dragonBones_BoneData_name_set)); + cls->defineProperty("parent", _SE(js_dragonBones_BoneData_parent_get), _SE(js_dragonBones_BoneData_parent_set)); + + cls->defineFunction("getTransfrom", _SE(js_dragonBones_BoneData_getTransfrom)); + cls->defineFunction("getParent", _SE(js_dragonBones_BoneData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_BoneData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BoneData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BoneData_proto = cls->getProto(); + __jsb_dragonBones_BoneData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_SlotData_class = nullptr; +se::Object* __jsb_dragonBones_SlotData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_SlotData) + +static bool js_dragonBones_SlotData_blendMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_blendMode_set) + +static bool js_dragonBones_SlotData_blendMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_blendMode_get) + +static bool js_dragonBones_SlotData_displayIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displayIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_displayIndex_set) + +static bool js_dragonBones_SlotData_displayIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displayIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_displayIndex_get) + +static bool js_dragonBones_SlotData_zOrder_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->zOrder, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_zOrder_set) + +static bool js_dragonBones_SlotData_zOrder_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->zOrder, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_zOrder_get) + +static bool js_dragonBones_SlotData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_name_set) + +static bool js_dragonBones_SlotData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_name_get) + +static bool js_dragonBones_SlotData_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_parent_set) + +static bool js_dragonBones_SlotData_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_parent_get) + +static bool js_delete_dragonBones_SlotData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_SlotData) + +static bool js_dragonBones_SlotData_getBlendMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::SlotData const *)arg1)->getBlendMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_SlotData_getBlendMode) + +static bool js_dragonBones_SlotData_setBlendMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBlendMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_SlotData_setBlendMode) + +static bool js_dragonBones_SlotData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + dragonBones::BoneData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoneData *)((dragonBones::SlotData const *)arg1)->getParent(); + + 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_dragonBones_SlotData_getParent) + +static bool js_dragonBones_SlotData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + dragonBones::BoneData *arg2 = (dragonBones::BoneData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_SlotData_setParent) + +bool js_register_dragonBones_SlotData(se::Object* obj) { + auto* cls = se::Class::create("SlotData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("blendMode", _SE(js_dragonBones_SlotData_blendMode_get), _SE(js_dragonBones_SlotData_blendMode_set)); + cls->defineProperty("displayIndex", _SE(js_dragonBones_SlotData_displayIndex_get), _SE(js_dragonBones_SlotData_displayIndex_set)); + cls->defineProperty("zOrder", _SE(js_dragonBones_SlotData_zOrder_get), _SE(js_dragonBones_SlotData_zOrder_set)); + cls->defineProperty("name", _SE(js_dragonBones_SlotData_name_get), _SE(js_dragonBones_SlotData_name_set)); + cls->defineProperty("parent", _SE(js_dragonBones_SlotData_parent_get), _SE(js_dragonBones_SlotData_parent_set)); + + cls->defineFunction("getBlendMode", _SE(js_dragonBones_SlotData_getBlendMode)); + cls->defineFunction("setBlendMode", _SE(js_dragonBones_SlotData_setBlendMode)); + cls->defineFunction("getParent", _SE(js_dragonBones_SlotData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_SlotData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_SlotData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_SlotData_proto = cls->getProto(); + __jsb_dragonBones_SlotData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_SkinData_class = nullptr; +se::Object* __jsb_dragonBones_SkinData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_SkinData) + +static bool js_delete_dragonBones_SkinData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_SkinData) + +static bool js_dragonBones_SkinData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SkinData *arg1 = (dragonBones::SkinData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SkinData_name_set) + +static bool js_dragonBones_SkinData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SkinData *arg1 = (dragonBones::SkinData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SkinData_name_get) + +bool js_register_dragonBones_SkinData(se::Object* obj) { + auto* cls = se::Class::create("SkinData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_dragonBones_SkinData_name_get), _SE(js_dragonBones_SkinData_name_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_SkinData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_SkinData_proto = cls->getProto(); + __jsb_dragonBones_SkinData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_AnimationData_class = nullptr; +se::Object* __jsb_dragonBones_AnimationData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_AnimationData) + +static bool js_dragonBones_AnimationData_frameCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frameCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_frameCount_set) + +static bool js_dragonBones_AnimationData_frameCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frameCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_frameCount_get) + +static bool js_dragonBones_AnimationData_playTimes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->playTimes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_playTimes_set) + +static bool js_dragonBones_AnimationData_playTimes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->playTimes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_playTimes_get) + +static bool js_dragonBones_AnimationData_duration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->duration, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_duration_set) + +static bool js_dragonBones_AnimationData_duration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->duration, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_duration_get) + +static bool js_dragonBones_AnimationData_fadeInTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fadeInTime, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_fadeInTime_set) + +static bool js_dragonBones_AnimationData_fadeInTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fadeInTime, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_fadeInTime_get) + +static bool js_dragonBones_AnimationData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_name_set) + +static bool js_dragonBones_AnimationData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_name_get) + +static bool js_delete_dragonBones_AnimationData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_AnimationData) + +static bool js_dragonBones_AnimationData_getBoneCachedFrameIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + std::vector< int > *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(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 = (std::vector< int > *)(arg1)->getBoneCachedFrameIndices((std::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_dragonBones_AnimationData_getBoneCachedFrameIndices) + +static bool js_dragonBones_AnimationData_getSlotCachedFrameIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + std::vector< int > *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(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 = (std::vector< int > *)(arg1)->getSlotCachedFrameIndices((std::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_dragonBones_AnimationData_getSlotCachedFrameIndices) + +static bool js_dragonBones_AnimationData_getZOrderTimeline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + dragonBones::TimelineData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::TimelineData *)((dragonBones::AnimationData const *)arg1)->getZOrderTimeline(); + + 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_dragonBones_AnimationData_getZOrderTimeline) + +static bool js_dragonBones_AnimationData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + dragonBones::ArmatureData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::ArmatureData *)((dragonBones::AnimationData const *)arg1)->getParent(); + + 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_dragonBones_AnimationData_getParent) + +static bool js_dragonBones_AnimationData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + dragonBones::ArmatureData *arg2 = (dragonBones::ArmatureData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationData_setParent) + +bool js_register_dragonBones_AnimationData(se::Object* obj) { + auto* cls = se::Class::create("AnimationData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frameCount", _SE(js_dragonBones_AnimationData_frameCount_get), _SE(js_dragonBones_AnimationData_frameCount_set)); + cls->defineProperty("playTimes", _SE(js_dragonBones_AnimationData_playTimes_get), _SE(js_dragonBones_AnimationData_playTimes_set)); + cls->defineProperty("duration", _SE(js_dragonBones_AnimationData_duration_get), _SE(js_dragonBones_AnimationData_duration_set)); + cls->defineProperty("fadeInTime", _SE(js_dragonBones_AnimationData_fadeInTime_get), _SE(js_dragonBones_AnimationData_fadeInTime_set)); + cls->defineProperty("name", _SE(js_dragonBones_AnimationData_name_get), _SE(js_dragonBones_AnimationData_name_set)); + + cls->defineFunction("getBoneCachedFrameIndices", _SE(js_dragonBones_AnimationData_getBoneCachedFrameIndices)); + cls->defineFunction("getSlotCachedFrameIndices", _SE(js_dragonBones_AnimationData_getSlotCachedFrameIndices)); + cls->defineFunction("getZOrderTimeline", _SE(js_dragonBones_AnimationData_getZOrderTimeline)); + cls->defineFunction("getParent", _SE(js_dragonBones_AnimationData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_AnimationData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_AnimationData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_AnimationData_proto = cls->getProto(); + __jsb_dragonBones_AnimationData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TimelineData_class = nullptr; +se::Object* __jsb_dragonBones_TimelineData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TimelineData) + +static bool js_dragonBones_TimelineData_getTypeIndex_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = dragonBones::TimelineData::getTypeIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TimelineData_getTypeIndex_static) + +static bool js_new_dragonBones_TimelineData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::TimelineData *result; + result = (dragonBones::TimelineData *)new dragonBones::TimelineData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_TimelineData, __jsb_dragonBones_TimelineData_class, js_delete_dragonBones_TimelineData) + +static bool js_delete_dragonBones_TimelineData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TimelineData) + +static bool js_dragonBones_TimelineData_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TimelineData_type_set) + +static bool js_dragonBones_TimelineData_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TimelineData_type_get) + +static bool js_dragonBones_TimelineData_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TimelineData_offset_set) + +static bool js_dragonBones_TimelineData_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TimelineData_offset_get) + +static bool js_dragonBones_TimelineData_frameIndicesOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frameIndicesOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TimelineData_frameIndicesOffset_set) + +static bool js_dragonBones_TimelineData_frameIndicesOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frameIndicesOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TimelineData_frameIndicesOffset_get) + +static bool js_dragonBones_TimelineData_getType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::TimelineData const *)arg1)->getType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TimelineData_getType) + +static bool js_dragonBones_TimelineData_setType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setType(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TimelineData_setType) + +bool js_register_dragonBones_TimelineData(se::Object* obj) { + auto* cls = se::Class::create("TimelineData", obj, __jsb_dragonBones_BaseObject_proto, _SE(js_new_dragonBones_TimelineData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_dragonBones_TimelineData_type_get), _SE(js_dragonBones_TimelineData_type_set)); + cls->defineProperty("offset", _SE(js_dragonBones_TimelineData_offset_get), _SE(js_dragonBones_TimelineData_offset_set)); + cls->defineProperty("frameIndicesOffset", _SE(js_dragonBones_TimelineData_frameIndicesOffset_get), _SE(js_dragonBones_TimelineData_frameIndicesOffset_set)); + + cls->defineFunction("getType", _SE(js_dragonBones_TimelineData_getType)); + cls->defineFunction("setType", _SE(js_dragonBones_TimelineData_setType)); + + + cls->defineStaticFunction("getTypeIndex", _SE(js_dragonBones_TimelineData_getTypeIndex_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TimelineData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TimelineData_proto = cls->getProto(); + __jsb_dragonBones_TimelineData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_WorldClock_class = nullptr; +se::Object* __jsb_dragonBones_WorldClock_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_WorldClock) + +static bool js_dragonBones_WorldClock_time_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->time, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_WorldClock_time_set) + +static bool js_dragonBones_WorldClock_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->time, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_WorldClock_time_get) + +static bool js_dragonBones_WorldClock_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_WorldClock_timeScale_set) + +static bool js_dragonBones_WorldClock_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_WorldClock_timeScale_get) + +static bool js_delete_dragonBones_WorldClock(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_WorldClock) + +static bool js_dragonBones_WorldClock_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->advanceTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_advanceTime) + +static bool js_dragonBones_WorldClock_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->render(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_render) + +static bool js_dragonBones_WorldClock_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_clear) + +static bool js_dragonBones_WorldClock_getClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + dragonBones::WorldClock *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::WorldClock *)((dragonBones::WorldClock const *)arg1)->getClock(); + + 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_dragonBones_WorldClock_getClock) + +static bool js_dragonBones_WorldClock_setClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + dragonBones::WorldClock *arg2 = (dragonBones::WorldClock *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setClock(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_setClock) + +static bool js_dragonBones_WorldClock_getStaticClock_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::WorldClock *)dragonBones::WorldClock::getStaticClock(); + + 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_dragonBones_WorldClock_getStaticClock_static) + +bool js_register_dragonBones_WorldClock(se::Object* obj) { + auto* cls = se::Class::create("WorldClock", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("time", _SE(js_dragonBones_WorldClock_time_get), _SE(js_dragonBones_WorldClock_time_set)); + cls->defineProperty("timeScale", _SE(js_dragonBones_WorldClock_timeScale_get), _SE(js_dragonBones_WorldClock_timeScale_set)); + + cls->defineFunction("advanceTime", _SE(js_dragonBones_WorldClock_advanceTime)); + cls->defineFunction("render", _SE(js_dragonBones_WorldClock_render)); + cls->defineFunction("clear", _SE(js_dragonBones_WorldClock_clear)); + cls->defineFunction("getClock", _SE(js_dragonBones_WorldClock_getClock)); + cls->defineFunction("setClock", _SE(js_dragonBones_WorldClock_setClock)); + + + cls->defineStaticFunction("getStaticClock", _SE(js_dragonBones_WorldClock_getStaticClock_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_WorldClock)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_WorldClock_proto = cls->getProto(); + __jsb_dragonBones_WorldClock_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Animation_class = nullptr; +se::Object* __jsb_dragonBones_Animation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Animation) + +static bool js_dragonBones_Animation_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Animation_timeScale_set) + +static bool js_dragonBones_Animation_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Animation_timeScale_get) + +static bool js_delete_dragonBones_Animation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Animation) + +static bool js_dragonBones_Animation_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->init(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_init) + +static bool js_dragonBones_Animation_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->advanceTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_advanceTime) + +static bool js_dragonBones_Animation_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_reset) + +static bool js_dragonBones_Animation_stop__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->stop((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_Animation_stop__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stop(); + + + return true; +} + +static bool js_dragonBones_Animation_stop(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_dragonBones_Animation_stop__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_Animation_stop__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_stop) + +static bool js_dragonBones_Animation_play__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->play((std::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; +} + +static bool js_dragonBones_Animation_play__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->play((std::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; +} + +static bool js_dragonBones_Animation_play__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationState *)(arg1)->play(); + + 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_dragonBones_Animation_play(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_play__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_play__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_Animation_play__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_play) + +static bool js_dragonBones_Animation_fadeIn__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + int arg5 ; + std::string *arg6 = 0 ; + dragonBones::AnimationFadeOutMode arg7 ; + std::string temp2 ; + std::string temp6 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6,arg7); + + 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_dragonBones_Animation_fadeIn__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + int arg5 ; + std::string *arg6 = 0 ; + std::string temp2 ; + std::string temp6 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + int arg5 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->fadeIn((std::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; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->fadeIn((std::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; +} + +static bool js_dragonBones_Animation_fadeIn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_dragonBones_Animation_fadeIn__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_dragonBones_Animation_fadeIn__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_dragonBones_Animation_fadeIn__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_dragonBones_Animation_fadeIn__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_fadeIn__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_fadeIn__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_fadeIn) + +static bool js_dragonBones_Animation_gotoAndPlayByTime__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByTime((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_gotoAndPlayByTime__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByTime__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_Animation_gotoAndPlayByTime__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndPlayByTime__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndPlayByTime__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndPlayByTime) + +static bool js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + unsigned int arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByFrame((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + unsigned int arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndPlayByFrame) + +static bool js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByProgress((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByProgress(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndPlayByProgress) + +static bool js_dragonBones_Animation_gotoAndStopByTime__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByTime__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndStopByTime__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndStopByTime__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndStopByTime) + +static bool js_dragonBones_Animation_gotoAndStopByFrame__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + unsigned int arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByFrame__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndStopByFrame__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndStopByFrame__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndStopByFrame) + +static bool js_dragonBones_Animation_gotoAndStopByProgress__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByProgress__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByProgress(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndStopByProgress__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndStopByProgress__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndStopByProgress) + +static bool js_dragonBones_Animation_getState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *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(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 = (dragonBones::AnimationState *)((dragonBones::Animation const *)arg1)->getState((std::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_dragonBones_Animation_getState) + +static bool js_dragonBones_Animation_hasAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::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(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)((dragonBones::Animation const *)arg1)->hasAnimation((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_hasAnimation) + +static bool js_dragonBones_Animation_isPlaying(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Animation const *)arg1)->isPlaying(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_isPlaying) + +static bool js_dragonBones_Animation_isCompleted(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Animation const *)arg1)->isCompleted(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_isCompleted) + +static bool js_dragonBones_Animation_getLastAnimationName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Animation const *)arg1)->getLastAnimationName(); + + 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_dragonBones_Animation_getLastAnimationName) + +static bool js_dragonBones_Animation_getAnimationNames(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::vector< std::string > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< std::string > *) &((dragonBones::Animation const *)arg1)->getAnimationNames(); + + 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_dragonBones_Animation_getAnimationNames) + +static bool js_dragonBones_Animation_getLastAnimationState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + dragonBones::AnimationState *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationState *)((dragonBones::Animation const *)arg1)->getLastAnimationState(); + + 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_dragonBones_Animation_getLastAnimationState) + +bool js_register_dragonBones_Animation(se::Object* obj) { + auto* cls = se::Class::create("Animation", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("timeScale", _SE(js_dragonBones_Animation_timeScale_get), _SE(js_dragonBones_Animation_timeScale_set)); + + cls->defineFunction("init", _SE(js_dragonBones_Animation_init)); + cls->defineFunction("advanceTime", _SE(js_dragonBones_Animation_advanceTime)); + cls->defineFunction("reset", _SE(js_dragonBones_Animation_reset)); + cls->defineFunction("stop", _SE(js_dragonBones_Animation_stop)); + cls->defineFunction("play", _SE(js_dragonBones_Animation_play)); + cls->defineFunction("fadeIn", _SE(js_dragonBones_Animation_fadeIn)); + cls->defineFunction("gotoAndPlayByTime", _SE(js_dragonBones_Animation_gotoAndPlayByTime)); + cls->defineFunction("gotoAndPlayByFrame", _SE(js_dragonBones_Animation_gotoAndPlayByFrame)); + cls->defineFunction("gotoAndPlayByProgress", _SE(js_dragonBones_Animation_gotoAndPlayByProgress)); + cls->defineFunction("gotoAndStopByTime", _SE(js_dragonBones_Animation_gotoAndStopByTime)); + cls->defineFunction("gotoAndStopByFrame", _SE(js_dragonBones_Animation_gotoAndStopByFrame)); + cls->defineFunction("gotoAndStopByProgress", _SE(js_dragonBones_Animation_gotoAndStopByProgress)); + cls->defineFunction("getState", _SE(js_dragonBones_Animation_getState)); + cls->defineFunction("hasAnimation", _SE(js_dragonBones_Animation_hasAnimation)); + cls->defineFunction("isPlaying", _SE(js_dragonBones_Animation_isPlaying)); + cls->defineFunction("isCompleted", _SE(js_dragonBones_Animation_isCompleted)); + cls->defineFunction("getLastAnimationName", _SE(js_dragonBones_Animation_getLastAnimationName)); + cls->defineFunction("getAnimationNames", _SE(js_dragonBones_Animation_getAnimationNames)); + cls->defineFunction("getLastAnimationState", _SE(js_dragonBones_Animation_getLastAnimationState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Animation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Animation_proto = cls->getProto(); + __jsb_dragonBones_Animation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_AnimationState_class = nullptr; +se::Object* __jsb_dragonBones_AnimationState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_AnimationState) + +static bool js_dragonBones_AnimationState_actionEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->actionEnabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_actionEnabled_set) + +static bool js_dragonBones_AnimationState_actionEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->actionEnabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_actionEnabled_get) + +static bool js_dragonBones_AnimationState_additiveBlending_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->additiveBlending); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_additiveBlending_set) + +static bool js_dragonBones_AnimationState_additiveBlending_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->additiveBlending, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_additiveBlending_get) + +static bool js_dragonBones_AnimationState_displayControl_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displayControl); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_displayControl_set) + +static bool js_dragonBones_AnimationState_displayControl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displayControl, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_displayControl_get) + +static bool js_dragonBones_AnimationState_resetToPose_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->resetToPose); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_resetToPose_set) + +static bool js_dragonBones_AnimationState_resetToPose_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->resetToPose, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_resetToPose_get) + +static bool js_dragonBones_AnimationState_playTimes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->playTimes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_playTimes_set) + +static bool js_dragonBones_AnimationState_playTimes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->playTimes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_playTimes_get) + +static bool js_dragonBones_AnimationState_layer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_layer_set) + +static bool js_dragonBones_AnimationState_layer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_layer_get) + +static bool js_dragonBones_AnimationState_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_timeScale_set) + +static bool js_dragonBones_AnimationState_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_timeScale_get) + +static bool js_dragonBones_AnimationState_weight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->weight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_weight_set) + +static bool js_dragonBones_AnimationState_weight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->weight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_weight_get) + +static bool js_dragonBones_AnimationState_autoFadeOutTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->autoFadeOutTime, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_autoFadeOutTime_set) + +static bool js_dragonBones_AnimationState_autoFadeOutTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->autoFadeOutTime, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_autoFadeOutTime_get) + +static bool js_dragonBones_AnimationState_fadeTotalTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fadeTotalTime, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_fadeTotalTime_set) + +static bool js_dragonBones_AnimationState_fadeTotalTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fadeTotalTime, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_fadeTotalTime_get) + +static bool js_dragonBones_AnimationState_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_name_set) + +static bool js_dragonBones_AnimationState_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_name_get) + +static bool js_dragonBones_AnimationState_group_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->group, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_group_set) + +static bool js_dragonBones_AnimationState_group_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->group, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->group, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_group_get) + +static bool js_dragonBones_AnimationState__playheadState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_playheadState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__playheadState_set) + +static bool js_dragonBones_AnimationState__playheadState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_playheadState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__playheadState_get) + +static bool js_dragonBones_AnimationState__fadeState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fadeState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__fadeState_set) + +static bool js_dragonBones_AnimationState__fadeState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fadeState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__fadeState_get) + +static bool js_dragonBones_AnimationState__subFadeState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_subFadeState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__subFadeState_set) + +static bool js_dragonBones_AnimationState__subFadeState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_subFadeState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__subFadeState_get) + +static bool js_dragonBones_AnimationState__position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__position_set) + +static bool js_dragonBones_AnimationState__position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_position, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__position_get) + +static bool js_dragonBones_AnimationState__duration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_duration, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__duration_set) + +static bool js_dragonBones_AnimationState__duration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_duration, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__duration_get) + +static bool js_dragonBones_AnimationState__fadeProgress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fadeProgress, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__fadeProgress_set) + +static bool js_dragonBones_AnimationState__fadeProgress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fadeProgress, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__fadeProgress_get) + +static bool js_dragonBones_AnimationState__weightResult_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_weightResult, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__weightResult_set) + +static bool js_dragonBones_AnimationState__weightResult_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_weightResult, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__weightResult_get) + +static bool js_dragonBones_AnimationState__animationData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_animationData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__animationData_set) + +static bool js_dragonBones_AnimationState__animationData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_animationData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_animationData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__animationData_get) + +static bool js_delete_dragonBones_AnimationState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_AnimationState) + +static bool js_dragonBones_AnimationState_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->advanceTime(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_advanceTime) + +static bool js_dragonBones_AnimationState_play(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->play(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_play) + +static bool js_dragonBones_AnimationState_stop(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stop(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_stop) + +static bool js_dragonBones_AnimationState_fadeOut__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + bool arg3 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->fadeOut(arg2,arg3); + + + return true; +} + +static bool js_dragonBones_AnimationState_fadeOut__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->fadeOut(arg2); + + + return true; +} + +static bool js_dragonBones_AnimationState_fadeOut(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_AnimationState_fadeOut__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_AnimationState_fadeOut__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_fadeOut) + +static bool js_dragonBones_AnimationState_containsBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + std::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(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)((dragonBones::AnimationState const *)arg1)->containsBoneMask((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_containsBoneMask) + +static bool js_dragonBones_AnimationState_addBoneMask__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addBoneMask((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_AnimationState_addBoneMask__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addBoneMask((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_AnimationState_addBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_AnimationState_addBoneMask__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_AnimationState_addBoneMask__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_addBoneMask) + +static bool js_dragonBones_AnimationState_removeBoneMask__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeBoneMask((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_AnimationState_removeBoneMask__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeBoneMask((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_AnimationState_removeBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_AnimationState_removeBoneMask__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_AnimationState_removeBoneMask__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_removeBoneMask) + +static bool js_dragonBones_AnimationState_removeAllBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeAllBoneMask(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_removeAllBoneMask) + +static bool js_dragonBones_AnimationState_isFadeIn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isFadeIn(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isFadeIn) + +static bool js_dragonBones_AnimationState_isFadeOut(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isFadeOut(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isFadeOut) + +static bool js_dragonBones_AnimationState_isFadeComplete(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isFadeComplete(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isFadeComplete) + +static bool js_dragonBones_AnimationState_isPlaying(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isPlaying(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isPlaying) + +static bool js_dragonBones_AnimationState_isCompleted(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isCompleted(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isCompleted) + +static bool js_dragonBones_AnimationState_getCurrentPlayTimes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + unsigned int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (unsigned int)((dragonBones::AnimationState const *)arg1)->getCurrentPlayTimes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_getCurrentPlayTimes) + +static bool js_dragonBones_AnimationState_getTotalTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((dragonBones::AnimationState const *)arg1)->getTotalTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_getTotalTime) + +static bool js_dragonBones_AnimationState_getCurrentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((dragonBones::AnimationState const *)arg1)->getCurrentTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_getCurrentTime) + +static bool js_dragonBones_AnimationState_setCurrentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCurrentTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_setCurrentTime) + +static bool js_dragonBones_AnimationState_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::AnimationState const *)arg1)->getName(); + + 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_dragonBones_AnimationState_getName) + +static bool js_dragonBones_AnimationState_getAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + dragonBones::AnimationData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationData *)((dragonBones::AnimationState const *)arg1)->getAnimationData(); + + 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_dragonBones_AnimationState_getAnimationData) + +bool js_register_dragonBones_AnimationState(se::Object* obj) { + auto* cls = se::Class::create("AnimationState", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("actionEnabled", _SE(js_dragonBones_AnimationState_actionEnabled_get), _SE(js_dragonBones_AnimationState_actionEnabled_set)); + cls->defineProperty("additiveBlending", _SE(js_dragonBones_AnimationState_additiveBlending_get), _SE(js_dragonBones_AnimationState_additiveBlending_set)); + cls->defineProperty("displayControl", _SE(js_dragonBones_AnimationState_displayControl_get), _SE(js_dragonBones_AnimationState_displayControl_set)); + cls->defineProperty("resetToPose", _SE(js_dragonBones_AnimationState_resetToPose_get), _SE(js_dragonBones_AnimationState_resetToPose_set)); + cls->defineProperty("playTimes", _SE(js_dragonBones_AnimationState_playTimes_get), _SE(js_dragonBones_AnimationState_playTimes_set)); + cls->defineProperty("layer", _SE(js_dragonBones_AnimationState_layer_get), _SE(js_dragonBones_AnimationState_layer_set)); + cls->defineProperty("timeScale", _SE(js_dragonBones_AnimationState_timeScale_get), _SE(js_dragonBones_AnimationState_timeScale_set)); + cls->defineProperty("weight", _SE(js_dragonBones_AnimationState_weight_get), _SE(js_dragonBones_AnimationState_weight_set)); + cls->defineProperty("autoFadeOutTime", _SE(js_dragonBones_AnimationState_autoFadeOutTime_get), _SE(js_dragonBones_AnimationState_autoFadeOutTime_set)); + cls->defineProperty("fadeTotalTime", _SE(js_dragonBones_AnimationState_fadeTotalTime_get), _SE(js_dragonBones_AnimationState_fadeTotalTime_set)); + cls->defineProperty("name", _SE(js_dragonBones_AnimationState_name_get), _SE(js_dragonBones_AnimationState_name_set)); + cls->defineProperty("group", _SE(js_dragonBones_AnimationState_group_get), _SE(js_dragonBones_AnimationState_group_set)); + cls->defineProperty("_playheadState", _SE(js_dragonBones_AnimationState__playheadState_get), _SE(js_dragonBones_AnimationState__playheadState_set)); + cls->defineProperty("_fadeState", _SE(js_dragonBones_AnimationState__fadeState_get), _SE(js_dragonBones_AnimationState__fadeState_set)); + cls->defineProperty("_subFadeState", _SE(js_dragonBones_AnimationState__subFadeState_get), _SE(js_dragonBones_AnimationState__subFadeState_set)); + cls->defineProperty("_position", _SE(js_dragonBones_AnimationState__position_get), _SE(js_dragonBones_AnimationState__position_set)); + cls->defineProperty("_duration", _SE(js_dragonBones_AnimationState__duration_get), _SE(js_dragonBones_AnimationState__duration_set)); + cls->defineProperty("_fadeProgress", _SE(js_dragonBones_AnimationState__fadeProgress_get), _SE(js_dragonBones_AnimationState__fadeProgress_set)); + cls->defineProperty("_weightResult", _SE(js_dragonBones_AnimationState__weightResult_get), _SE(js_dragonBones_AnimationState__weightResult_set)); + cls->defineProperty("_animationData", _SE(js_dragonBones_AnimationState__animationData_get), _SE(js_dragonBones_AnimationState__animationData_set)); + + cls->defineFunction("advanceTime", _SE(js_dragonBones_AnimationState_advanceTime)); + cls->defineFunction("play", _SE(js_dragonBones_AnimationState_play)); + cls->defineFunction("stop", _SE(js_dragonBones_AnimationState_stop)); + cls->defineFunction("fadeOut", _SE(js_dragonBones_AnimationState_fadeOut)); + cls->defineFunction("containsBoneMask", _SE(js_dragonBones_AnimationState_containsBoneMask)); + cls->defineFunction("addBoneMask", _SE(js_dragonBones_AnimationState_addBoneMask)); + cls->defineFunction("removeBoneMask", _SE(js_dragonBones_AnimationState_removeBoneMask)); + cls->defineFunction("removeAllBoneMask", _SE(js_dragonBones_AnimationState_removeAllBoneMask)); + cls->defineFunction("isFadeIn", _SE(js_dragonBones_AnimationState_isFadeIn)); + cls->defineFunction("isFadeOut", _SE(js_dragonBones_AnimationState_isFadeOut)); + cls->defineFunction("isFadeComplete", _SE(js_dragonBones_AnimationState_isFadeComplete)); + cls->defineFunction("isPlaying", _SE(js_dragonBones_AnimationState_isPlaying)); + cls->defineFunction("isCompleted", _SE(js_dragonBones_AnimationState_isCompleted)); + cls->defineFunction("getCurrentPlayTimes", _SE(js_dragonBones_AnimationState_getCurrentPlayTimes)); + cls->defineFunction("getTotalTime", _SE(js_dragonBones_AnimationState_getTotalTime)); + cls->defineFunction("getCurrentTime", _SE(js_dragonBones_AnimationState_getCurrentTime)); + cls->defineFunction("setCurrentTime", _SE(js_dragonBones_AnimationState_setCurrentTime)); + cls->defineFunction("getName", _SE(js_dragonBones_AnimationState_getName)); + cls->defineFunction("getAnimationData", _SE(js_dragonBones_AnimationState_getAnimationData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_AnimationState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_AnimationState_proto = cls->getProto(); + __jsb_dragonBones_AnimationState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BonePose_class = nullptr; +se::Object* __jsb_dragonBones_BonePose_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BonePose) + +static bool js_dragonBones_BonePose_getTypeIndex_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = dragonBones::BonePose::getTypeIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BonePose_getTypeIndex_static) + +static bool js_new_dragonBones_BonePose(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::BonePose *result; + result = (dragonBones::BonePose *)new dragonBones::BonePose(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_BonePose, __jsb_dragonBones_BonePose_class, js_delete_dragonBones_BonePose) + +static bool js_delete_dragonBones_BonePose(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BonePose) + +static bool js_dragonBones_BonePose_current_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->current, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BonePose_current_set) + +static bool js_dragonBones_BonePose_current_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->current, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->current, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BonePose_current_get) + +static bool js_dragonBones_BonePose_delta_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->delta, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BonePose_delta_set) + +static bool js_dragonBones_BonePose_delta_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->delta, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->delta, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BonePose_delta_get) + +static bool js_dragonBones_BonePose_result_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->result, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BonePose_result_set) + +static bool js_dragonBones_BonePose_result_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BonePose_result_get) + +bool js_register_dragonBones_BonePose(se::Object* obj) { + auto* cls = se::Class::create("BonePose", obj, __jsb_dragonBones_BaseObject_proto, _SE(js_new_dragonBones_BonePose)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("current", _SE(js_dragonBones_BonePose_current_get), _SE(js_dragonBones_BonePose_current_set)); + cls->defineProperty("delta", _SE(js_dragonBones_BonePose_delta_get), _SE(js_dragonBones_BonePose_delta_set)); + cls->defineProperty("result", _SE(js_dragonBones_BonePose_result_get), _SE(js_dragonBones_BonePose_result_set)); + + + + cls->defineStaticFunction("getTypeIndex", _SE(js_dragonBones_BonePose_getTypeIndex_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BonePose)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BonePose_proto = cls->getProto(); + __jsb_dragonBones_BonePose_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BlendState_class = nullptr; +se::Object* __jsb_dragonBones_BlendState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BlendState) + +static bool js_dragonBones_BlendState_dirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_dirty_set) + +static bool js_dragonBones_BlendState_dirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_dirty_get) + +static bool js_dragonBones_BlendState_layer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_layer_set) + +static bool js_dragonBones_BlendState_layer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_layer_get) + +static bool js_dragonBones_BlendState_leftWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->leftWeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_leftWeight_set) + +static bool js_dragonBones_BlendState_leftWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->leftWeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_leftWeight_get) + +static bool js_dragonBones_BlendState_layerWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerWeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_layerWeight_set) + +static bool js_dragonBones_BlendState_layerWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerWeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_layerWeight_get) + +static bool js_dragonBones_BlendState_blendWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendWeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_blendWeight_set) + +static bool js_dragonBones_BlendState_blendWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendWeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_blendWeight_get) + +static bool js_dragonBones_BlendState_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + float arg2 ; + int arg3 ; + int result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->update(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BlendState_update) + +static bool js_dragonBones_BlendState_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BlendState_clear) + +static bool js_new_dragonBones_BlendState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::BlendState *result; + result = (dragonBones::BlendState *)new dragonBones::BlendState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_BlendState, __jsb_dragonBones_BlendState_class, js_delete_dragonBones_BlendState) + +static bool js_delete_dragonBones_BlendState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BlendState) + +bool js_register_dragonBones_BlendState(se::Object* obj) { + auto* cls = se::Class::create("BlendState", obj, nullptr, _SE(js_new_dragonBones_BlendState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dirty", _SE(js_dragonBones_BlendState_dirty_get), _SE(js_dragonBones_BlendState_dirty_set)); + cls->defineProperty("layer", _SE(js_dragonBones_BlendState_layer_get), _SE(js_dragonBones_BlendState_layer_set)); + cls->defineProperty("leftWeight", _SE(js_dragonBones_BlendState_leftWeight_get), _SE(js_dragonBones_BlendState_leftWeight_set)); + cls->defineProperty("layerWeight", _SE(js_dragonBones_BlendState_layerWeight_get), _SE(js_dragonBones_BlendState_layerWeight_set)); + cls->defineProperty("blendWeight", _SE(js_dragonBones_BlendState_blendWeight_get), _SE(js_dragonBones_BlendState_blendWeight_set)); + + cls->defineFunction("update", _SE(js_dragonBones_BlendState_update)); + cls->defineFunction("clear", _SE(js_dragonBones_BlendState_clear)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BlendState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BlendState_proto = cls->getProto(); + __jsb_dragonBones_BlendState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TransformObject_class = nullptr; +se::Object* __jsb_dragonBones_TransformObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TransformObject) + +static bool js_delete_dragonBones_TransformObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TransformObject) + +static bool js_dragonBones_TransformObject_globalTransformMatrix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->globalTransformMatrix, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_globalTransformMatrix_set) + +static bool js_dragonBones_TransformObject_globalTransformMatrix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->globalTransformMatrix, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->globalTransformMatrix, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_globalTransformMatrix_get) + +static bool js_dragonBones_TransformObject_global_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->global, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_global_set) + +static bool js_dragonBones_TransformObject_global_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->global, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->global, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_global_get) + +static bool js_dragonBones_TransformObject_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_offset_set) + +static bool js_dragonBones_TransformObject_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->offset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_offset_get) + +static bool js_dragonBones_TransformObject_origin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->origin, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_origin_set) + +static bool js_dragonBones_TransformObject_origin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->origin, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->origin, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_origin_get) + +static bool js_dragonBones_TransformObject_userData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->userData); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_userData_set) + +static bool js_dragonBones_TransformObject_userData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->userData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->userData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_userData_get) + +static bool js_dragonBones_TransformObject__armature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_armature, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject__armature_set) + +static bool js_dragonBones_TransformObject__armature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_armature, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_armature, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject__armature_get) + +static bool js_dragonBones_TransformObject_updateGlobalTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateGlobalTransform(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TransformObject_updateGlobalTransform) + +static bool js_dragonBones_TransformObject_getArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::TransformObject const *)arg1)->getArmature(); + + 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_dragonBones_TransformObject_getArmature) + +static bool js_dragonBones_TransformObject_getGlobalTransformMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Matrix *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Matrix *)(arg1)->getGlobalTransformMatrix(); + + 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_dragonBones_TransformObject_getGlobalTransformMatrix) + +static bool js_dragonBones_TransformObject_getGlobal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)(arg1)->getGlobal(); + + 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_dragonBones_TransformObject_getGlobal) + +static bool js_dragonBones_TransformObject_getOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)(arg1)->getOffset(); + + 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_dragonBones_TransformObject_getOffset) + +static bool js_dragonBones_TransformObject_getOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)((dragonBones::TransformObject const *)arg1)->getOrigin(); + + 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_dragonBones_TransformObject_getOrigin) + +bool js_register_dragonBones_TransformObject(se::Object* obj) { + auto* cls = se::Class::create("TransformObject", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("globalTransformMatrix", _SE(js_dragonBones_TransformObject_globalTransformMatrix_get), _SE(js_dragonBones_TransformObject_globalTransformMatrix_set)); + cls->defineProperty("global", _SE(js_dragonBones_TransformObject_global_get), _SE(js_dragonBones_TransformObject_global_set)); + cls->defineProperty("offset", _SE(js_dragonBones_TransformObject_offset_get), _SE(js_dragonBones_TransformObject_offset_set)); + cls->defineProperty("origin", _SE(js_dragonBones_TransformObject_origin_get), _SE(js_dragonBones_TransformObject_origin_set)); + cls->defineProperty("userData", _SE(js_dragonBones_TransformObject_userData_get), _SE(js_dragonBones_TransformObject_userData_set)); + cls->defineProperty("_armature", _SE(js_dragonBones_TransformObject__armature_get), _SE(js_dragonBones_TransformObject__armature_set)); + + cls->defineFunction("updateGlobalTransform", _SE(js_dragonBones_TransformObject_updateGlobalTransform)); + cls->defineFunction("getArmature", _SE(js_dragonBones_TransformObject_getArmature)); + cls->defineFunction("getGlobalTransformMatrix", _SE(js_dragonBones_TransformObject_getGlobalTransformMatrix)); + cls->defineFunction("getGlobal", _SE(js_dragonBones_TransformObject_getGlobal)); + cls->defineFunction("getOffset", _SE(js_dragonBones_TransformObject_getOffset)); + cls->defineFunction("getOrigin", _SE(js_dragonBones_TransformObject_getOrigin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TransformObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TransformObject_proto = cls->getProto(); + __jsb_dragonBones_TransformObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Slot_class = nullptr; +se::Object* __jsb_dragonBones_Slot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Slot) + +static bool js_dragonBones_Slot_displayController_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displayController, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Slot_displayController_set) + +static bool js_dragonBones_Slot_displayController_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displayController, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->displayController, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Slot_displayController_get) + +static bool js_dragonBones_Slot__zOrder_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_zOrder, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Slot__zOrder_set) + +static bool js_dragonBones_Slot__zOrder_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_zOrder, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Slot__zOrder_get) + +static bool js_delete_dragonBones_Slot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Slot) + +static bool js_dragonBones_Slot__updateColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->_updateColor(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot__updateColor) + +static bool js_dragonBones_Slot__setZorder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->_setZorder(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot__setZorder) + +static bool js_dragonBones_Slot_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_update) + +static bool js_dragonBones_Slot_updateTransformAndMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateTransformAndMatrix(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_updateTransformAndMatrix) + +static bool js_dragonBones_Slot_containsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + float arg2 ; + float arg3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->containsPoint(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_containsPoint) + +static bool js_dragonBones_Slot_invalidUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidUpdate(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_invalidUpdate) + +static bool js_dragonBones_Slot_getVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Slot const *)arg1)->getVisible(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_getVisible) + +static bool js_dragonBones_Slot_setVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setVisible(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_setVisible) + +static bool js_dragonBones_Slot_getDisplayIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::Slot const *)arg1)->getDisplayIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_getDisplayIndex) + +static bool js_dragonBones_Slot_setDisplayIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDisplayIndex(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_setDisplayIndex) + +static bool js_dragonBones_Slot_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Slot const *)arg1)->getName(); + + 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_dragonBones_Slot_getName) + +static bool js_dragonBones_Slot_getRawDisplayDatas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + std::vector< dragonBones::DisplayData * > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< dragonBones::DisplayData * > *)((dragonBones::Slot const *)arg1)->getRawDisplayDatas(); + + 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_dragonBones_Slot_getRawDisplayDatas) + +static bool js_dragonBones_Slot_getSlotData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::SlotData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::SlotData *)((dragonBones::Slot const *)arg1)->getSlotData(); + + 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_dragonBones_Slot_getSlotData) + +static bool js_dragonBones_Slot_getBoundingBoxData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::BoundingBoxData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoundingBoxData *)((dragonBones::Slot const *)arg1)->getBoundingBoxData(); + + 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_dragonBones_Slot_getBoundingBoxData) + +static bool js_dragonBones_Slot_getChildArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::Slot const *)arg1)->getChildArmature(); + + 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_dragonBones_Slot_getChildArmature) + +static bool js_dragonBones_Slot_setChildArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setChildArmature(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_setChildArmature) + +static bool js_dragonBones_Slot_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::Bone *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Bone *)((dragonBones::Slot const *)arg1)->getParent(); + + 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_dragonBones_Slot_getParent) + +bool js_register_dragonBones_Slot(se::Object* obj) { + auto* cls = se::Class::create("Slot", obj, __jsb_dragonBones_TransformObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("displayController", _SE(js_dragonBones_Slot_displayController_get), _SE(js_dragonBones_Slot_displayController_set)); + cls->defineProperty("_zOrder", _SE(js_dragonBones_Slot__zOrder_get), _SE(js_dragonBones_Slot__zOrder_set)); + + cls->defineFunction("_updateColor", _SE(js_dragonBones_Slot__updateColor)); + cls->defineFunction("_setZorder", _SE(js_dragonBones_Slot__setZorder)); + cls->defineFunction("update", _SE(js_dragonBones_Slot_update)); + cls->defineFunction("updateTransformAndMatrix", _SE(js_dragonBones_Slot_updateTransformAndMatrix)); + cls->defineFunction("containsPoint", _SE(js_dragonBones_Slot_containsPoint)); + cls->defineFunction("invalidUpdate", _SE(js_dragonBones_Slot_invalidUpdate)); + cls->defineFunction("getVisible", _SE(js_dragonBones_Slot_getVisible)); + cls->defineFunction("setVisible", _SE(js_dragonBones_Slot_setVisible)); + cls->defineFunction("getDisplayIndex", _SE(js_dragonBones_Slot_getDisplayIndex)); + cls->defineFunction("setDisplayIndex", _SE(js_dragonBones_Slot_setDisplayIndex)); + cls->defineFunction("getName", _SE(js_dragonBones_Slot_getName)); + cls->defineFunction("getRawDisplayDatas", _SE(js_dragonBones_Slot_getRawDisplayDatas)); + cls->defineFunction("getSlotData", _SE(js_dragonBones_Slot_getSlotData)); + cls->defineFunction("getBoundingBoxData", _SE(js_dragonBones_Slot_getBoundingBoxData)); + cls->defineFunction("getChildArmature", _SE(js_dragonBones_Slot_getChildArmature)); + cls->defineFunction("setChildArmature", _SE(js_dragonBones_Slot_setChildArmature)); + cls->defineFunction("getParent", _SE(js_dragonBones_Slot_getParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Slot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Slot_proto = cls->getProto(); + __jsb_dragonBones_Slot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Bone_class = nullptr; +se::Object* __jsb_dragonBones_Bone_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Bone) + +static bool js_delete_dragonBones_Bone(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Bone) + +static bool js_dragonBones_Bone_offsetMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offsetMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone_offsetMode_set) + +static bool js_dragonBones_Bone_offsetMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offsetMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->offsetMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone_offsetMode_get) + +static bool js_dragonBones_Bone_animationPose_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->animationPose, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone_animationPose_set) + +static bool js_dragonBones_Bone_animationPose_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->animationPose, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->animationPose, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone_animationPose_get) + +static bool js_dragonBones_Bone__transformDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_transformDirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__transformDirty_set) + +static bool js_dragonBones_Bone__transformDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_transformDirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__transformDirty_get) + +static bool js_dragonBones_Bone__childrenTransformDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_childrenTransformDirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__childrenTransformDirty_set) + +static bool js_dragonBones_Bone__childrenTransformDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_childrenTransformDirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__childrenTransformDirty_get) + +static bool js_dragonBones_Bone__hasConstraint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_hasConstraint); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__hasConstraint_set) + +static bool js_dragonBones_Bone__hasConstraint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_hasConstraint, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__hasConstraint_get) + +static bool js_dragonBones_Bone__blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__blendState_set) + +static bool js_dragonBones_Bone__blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__blendState_get) + +static bool js_dragonBones_Bone__boneData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_boneData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__boneData_set) + +static bool js_dragonBones_Bone__boneData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_boneData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_boneData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__boneData_get) + +static bool js_dragonBones_Bone_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::BoneData *arg2 = (dragonBones::BoneData *) NULL ; + dragonBones::Armature *arg3 = (dragonBones::Armature *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->init((dragonBones::BoneData const *)arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_init) + +static bool js_dragonBones_Bone_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_update) + +static bool js_dragonBones_Bone_updateByConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateByConstraint(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_updateByConstraint) + +static bool js_dragonBones_Bone_invalidUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidUpdate(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_invalidUpdate) + +static bool js_dragonBones_Bone_contains(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::Bone *arg2 = (dragonBones::Bone *) 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::Bone const *)arg1)->contains((dragonBones::Bone const *)arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_contains) + +static bool js_dragonBones_Bone_getBoneData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::BoneData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoneData *)((dragonBones::Bone const *)arg1)->getBoneData(); + + 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_dragonBones_Bone_getBoneData) + +static bool js_dragonBones_Bone_getVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Bone const *)arg1)->getVisible(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_getVisible) + +static bool js_dragonBones_Bone_setVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setVisible(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_setVisible) + +static bool js_dragonBones_Bone_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Bone const *)arg1)->getName(); + + 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_dragonBones_Bone_getName) + +static bool js_dragonBones_Bone_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::Bone *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Bone *)((dragonBones::Bone const *)arg1)->getParent(); + + 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_dragonBones_Bone_getParent) + +static bool js_dragonBones_Bone_getOffsetMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::Bone const *)arg1)->getOffsetMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_getOffsetMode) + +static bool js_dragonBones_Bone_setOffsetMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOffsetMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_setOffsetMode) + +bool js_register_dragonBones_Bone(se::Object* obj) { + auto* cls = se::Class::create("Bone", obj, __jsb_dragonBones_TransformObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("offsetMode", _SE(js_dragonBones_Bone_offsetMode_get), _SE(js_dragonBones_Bone_offsetMode_set)); + cls->defineProperty("animationPose", _SE(js_dragonBones_Bone_animationPose_get), _SE(js_dragonBones_Bone_animationPose_set)); + cls->defineProperty("_transformDirty", _SE(js_dragonBones_Bone__transformDirty_get), _SE(js_dragonBones_Bone__transformDirty_set)); + cls->defineProperty("_childrenTransformDirty", _SE(js_dragonBones_Bone__childrenTransformDirty_get), _SE(js_dragonBones_Bone__childrenTransformDirty_set)); + cls->defineProperty("_hasConstraint", _SE(js_dragonBones_Bone__hasConstraint_get), _SE(js_dragonBones_Bone__hasConstraint_set)); + cls->defineProperty("_blendState", _SE(js_dragonBones_Bone__blendState_get), _SE(js_dragonBones_Bone__blendState_set)); + cls->defineProperty("_boneData", _SE(js_dragonBones_Bone__boneData_get), _SE(js_dragonBones_Bone__boneData_set)); + + cls->defineFunction("init", _SE(js_dragonBones_Bone_init)); + cls->defineFunction("update", _SE(js_dragonBones_Bone_update)); + cls->defineFunction("updateByConstraint", _SE(js_dragonBones_Bone_updateByConstraint)); + cls->defineFunction("invalidUpdate", _SE(js_dragonBones_Bone_invalidUpdate)); + cls->defineFunction("contains", _SE(js_dragonBones_Bone_contains)); + cls->defineFunction("getBoneData", _SE(js_dragonBones_Bone_getBoneData)); + cls->defineFunction("getVisible", _SE(js_dragonBones_Bone_getVisible)); + cls->defineFunction("setVisible", _SE(js_dragonBones_Bone_setVisible)); + cls->defineFunction("getName", _SE(js_dragonBones_Bone_getName)); + cls->defineFunction("getParent", _SE(js_dragonBones_Bone_getParent)); + cls->defineFunction("getOffsetMode", _SE(js_dragonBones_Bone_getOffsetMode)); + cls->defineFunction("setOffsetMode", _SE(js_dragonBones_Bone_setOffsetMode)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Bone)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Bone_proto = cls->getProto(); + __jsb_dragonBones_Bone_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Armature_class = nullptr; +se::Object* __jsb_dragonBones_Armature_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Armature) + +static bool js_dragonBones_Armature_inheritAnimation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inheritAnimation); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature_inheritAnimation_set) + +static bool js_dragonBones_Armature_inheritAnimation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inheritAnimation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature_inheritAnimation_get) + +static bool js_dragonBones_Armature_userData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->userData); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature_userData_set) + +static bool js_dragonBones_Armature_userData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->userData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->userData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature_userData_get) + +static bool js_dragonBones_Armature__cacheFrameIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_cacheFrameIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__cacheFrameIndex_set) + +static bool js_dragonBones_Armature__cacheFrameIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_cacheFrameIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__cacheFrameIndex_get) + +static bool js_dragonBones_Armature__armatureData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_armatureData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__armatureData_set) + +static bool js_dragonBones_Armature__armatureData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_armatureData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_armatureData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__armatureData_get) + +static bool js_dragonBones_Armature__parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__parent_set) + +static bool js_dragonBones_Armature__parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__parent_get) + +static bool js_dragonBones_Armature__replaceTextureAtlasData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_replaceTextureAtlasData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__replaceTextureAtlasData_set) + +static bool js_dragonBones_Armature__replaceTextureAtlasData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_replaceTextureAtlasData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_replaceTextureAtlasData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__replaceTextureAtlasData_get) + +static bool js_delete_dragonBones_Armature(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Armature) + +static bool js_dragonBones_Armature__addBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Bone *arg2 = (dragonBones::Bone *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_addBone(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature__addBone) + +static bool js_dragonBones_Armature__addSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Slot *arg2 = (dragonBones::Slot *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_addSlot(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature__addSlot) + +static bool js_dragonBones_Armature__bufferAction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::EventObject *arg2 = (dragonBones::EventObject *) NULL ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_bufferAction(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature__bufferAction) + +static bool js_dragonBones_Armature_dispose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dispose(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_dispose) + +static bool js_dragonBones_Armature_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->advanceTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_advanceTime) + +static bool js_dragonBones_Armature_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->render(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_render) + +static bool js_dragonBones_Armature_invalidUpdate__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->invalidUpdate((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_Armature_invalidUpdate__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->invalidUpdate((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_Armature_invalidUpdate__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidUpdate(); + + + return true; +} + +static bool js_dragonBones_Armature_invalidUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Armature_invalidUpdate__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Armature_invalidUpdate__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_Armature_invalidUpdate__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Armature_invalidUpdate) + +static bool js_dragonBones_Armature_containsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + float arg2 ; + float arg3 ; + dragonBones::Slot *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(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 = (dragonBones::Slot *)((dragonBones::Armature const *)arg1)->containsPoint(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_dragonBones_Armature_containsPoint) + +static bool js_dragonBones_Armature_getBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::Bone *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(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 = (dragonBones::Bone *)((dragonBones::Armature const *)arg1)->getBone((std::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_dragonBones_Armature_getBone) + +static bool js_dragonBones_Armature_getSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::Slot *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(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 = (dragonBones::Slot *)((dragonBones::Armature const *)arg1)->getSlot((std::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_dragonBones_Armature_getSlot) + +static bool js_dragonBones_Armature_getFlipX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Armature const *)arg1)->getFlipX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_getFlipX) + +static bool js_dragonBones_Armature_setFlipX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFlipX(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setFlipX) + +static bool js_dragonBones_Armature_getFlipY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Armature const *)arg1)->getFlipY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_getFlipY) + +static bool js_dragonBones_Armature_setFlipY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFlipY(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setFlipY) + +static bool js_dragonBones_Armature_getCacheFrameRate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + unsigned int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (unsigned int)((dragonBones::Armature const *)arg1)->getCacheFrameRate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_getCacheFrameRate) + +static bool js_dragonBones_Armature_setCacheFrameRate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + unsigned int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCacheFrameRate(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setCacheFrameRate) + +static bool js_dragonBones_Armature_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Armature const *)arg1)->getName(); + + 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_dragonBones_Armature_getName) + +static bool js_dragonBones_Armature_getArmatureData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::ArmatureData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::ArmatureData *)((dragonBones::Armature const *)arg1)->getArmatureData(); + + 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_dragonBones_Armature_getArmatureData) + +static bool js_dragonBones_Armature_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Animation *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Animation *)((dragonBones::Armature const *)arg1)->getAnimation(); + + 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_dragonBones_Armature_getAnimation) + +static bool js_dragonBones_Armature_getProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::IArmatureProxy *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::IArmatureProxy *)((dragonBones::Armature const *)arg1)->getProxy(); + + 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_dragonBones_Armature_getProxy) + +static bool js_dragonBones_Armature_getEventDispatcher(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::IEventDispatcher *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::IEventDispatcher *)((dragonBones::Armature const *)arg1)->getEventDispatcher(); + + 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_dragonBones_Armature_getEventDispatcher) + +static bool js_dragonBones_Armature_getClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::WorldClock *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::WorldClock *)((dragonBones::Armature const *)arg1)->getClock(); + + 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_dragonBones_Armature_getClock) + +static bool js_dragonBones_Armature_setClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::WorldClock *arg2 = (dragonBones::WorldClock *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setClock(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setClock) + +static bool js_dragonBones_Armature_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Slot *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Slot *)((dragonBones::Armature const *)arg1)->getParent(); + + 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_dragonBones_Armature_getParent) + +bool js_register_dragonBones_Armature(se::Object* obj) { + auto* cls = se::Class::create("Armature", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("inheritAnimation", _SE(js_dragonBones_Armature_inheritAnimation_get), _SE(js_dragonBones_Armature_inheritAnimation_set)); + cls->defineProperty("userData", _SE(js_dragonBones_Armature_userData_get), _SE(js_dragonBones_Armature_userData_set)); + cls->defineProperty("_cacheFrameIndex", _SE(js_dragonBones_Armature__cacheFrameIndex_get), _SE(js_dragonBones_Armature__cacheFrameIndex_set)); + cls->defineProperty("_armatureData", _SE(js_dragonBones_Armature__armatureData_get), _SE(js_dragonBones_Armature__armatureData_set)); + cls->defineProperty("_parent", _SE(js_dragonBones_Armature__parent_get), _SE(js_dragonBones_Armature__parent_set)); + cls->defineProperty("_replaceTextureAtlasData", _SE(js_dragonBones_Armature__replaceTextureAtlasData_get), _SE(js_dragonBones_Armature__replaceTextureAtlasData_set)); + + cls->defineFunction("_addBone", _SE(js_dragonBones_Armature__addBone)); + cls->defineFunction("_addSlot", _SE(js_dragonBones_Armature__addSlot)); + cls->defineFunction("_bufferAction", _SE(js_dragonBones_Armature__bufferAction)); + cls->defineFunction("dispose", _SE(js_dragonBones_Armature_dispose)); + cls->defineFunction("advanceTime", _SE(js_dragonBones_Armature_advanceTime)); + cls->defineFunction("render", _SE(js_dragonBones_Armature_render)); + cls->defineFunction("invalidUpdate", _SE(js_dragonBones_Armature_invalidUpdate)); + cls->defineFunction("containsPoint", _SE(js_dragonBones_Armature_containsPoint)); + cls->defineFunction("getBone", _SE(js_dragonBones_Armature_getBone)); + cls->defineFunction("getSlot", _SE(js_dragonBones_Armature_getSlot)); + cls->defineFunction("getFlipX", _SE(js_dragonBones_Armature_getFlipX)); + cls->defineFunction("setFlipX", _SE(js_dragonBones_Armature_setFlipX)); + cls->defineFunction("getFlipY", _SE(js_dragonBones_Armature_getFlipY)); + cls->defineFunction("setFlipY", _SE(js_dragonBones_Armature_setFlipY)); + cls->defineFunction("getCacheFrameRate", _SE(js_dragonBones_Armature_getCacheFrameRate)); + cls->defineFunction("setCacheFrameRate", _SE(js_dragonBones_Armature_setCacheFrameRate)); + cls->defineFunction("getName", _SE(js_dragonBones_Armature_getName)); + cls->defineFunction("getArmatureData", _SE(js_dragonBones_Armature_getArmatureData)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_Armature_getAnimation)); + cls->defineFunction("getProxy", _SE(js_dragonBones_Armature_getProxy)); + cls->defineFunction("getEventDispatcher", _SE(js_dragonBones_Armature_getEventDispatcher)); + cls->defineFunction("getClock", _SE(js_dragonBones_Armature_getClock)); + cls->defineFunction("setClock", _SE(js_dragonBones_Armature_setClock)); + cls->defineFunction("getParent", _SE(js_dragonBones_Armature_getParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Armature)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Armature_proto = cls->getProto(); + __jsb_dragonBones_Armature_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCArmatureDisplay_class = nullptr; +se::Object* __jsb_dragonBones_CCArmatureDisplay_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureDisplay) + +static bool js_dragonBones_CCArmatureDisplay_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::CCArmatureDisplay *)dragonBones::CCArmatureDisplay::create(); + + 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_dragonBones_CCArmatureDisplay_create_static) + +static bool js_new_dragonBones_CCArmatureDisplay(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::CCArmatureDisplay *result; + result = (dragonBones::CCArmatureDisplay *)new dragonBones::CCArmatureDisplay(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_CCArmatureDisplay, __jsb_dragonBones_CCArmatureDisplay_class, js_delete_dragonBones_CCArmatureDisplay) + +static bool js_delete_dragonBones_CCArmatureDisplay(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureDisplay) + +static bool js_dragonBones_CCArmatureDisplay_dbInit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->dbInit(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbInit) + +static bool js_dragonBones_CCArmatureDisplay_dbClear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dbClear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbClear) + +static bool js_dragonBones_CCArmatureDisplay_dbUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dbUpdate(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbUpdate) + +static bool js_dragonBones_CCArmatureDisplay_dbRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dbRender(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbRender) + +static bool js_dragonBones_CCArmatureDisplay_dispose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dispose(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dispose) + +static bool js_dragonBones_CCArmatureDisplay_hasDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + std::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(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)((dragonBones::CCArmatureDisplay const *)arg1)->hasDBEventListener((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_hasDBEventListener) + +static bool js_dragonBones_CCArmatureDisplay_dispatchDBEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + dragonBones::EventObject *arg3 = (dragonBones::EventObject *) NULL ; + std::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(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)->dispatchDBEvent((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dispatchDBEvent) + +static bool js_dragonBones_CCArmatureDisplay_addDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + std::function< void (dragonBones::EventObject *) > *arg3 = 0 ; + std::string temp2 ; + std::function< void (dragonBones::EventObject *) > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addDBEventListener((std::string const &)*arg2,(std::function< void (dragonBones::EventObject *) > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_addDBEventListener) + +static bool js_dragonBones_CCArmatureDisplay_removeDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + std::function< void (dragonBones::EventObject *) > *arg3 = 0 ; + std::string temp2 ; + std::function< void (dragonBones::EventObject *) > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeDBEventListener((std::string const &)*arg2,(std::function< void (dragonBones::EventObject *) > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_removeDBEventListener) + +static bool js_dragonBones_CCArmatureDisplay_setDBEventCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::CCArmatureDisplay::dbEventCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDBEventCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setDBEventCallback) + +static bool js_dragonBones_CCArmatureDisplay_armature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::CCArmatureDisplay const *)arg1)->getArmature(); + + 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_dragonBones_CCArmatureDisplay_armature) + +static bool js_dragonBones_CCArmatureDisplay_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::Animation *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Animation *)((dragonBones::CCArmatureDisplay const *)arg1)->getAnimation(); + + 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_dragonBones_CCArmatureDisplay_getAnimation) + +static bool js_dragonBones_CCArmatureDisplay_getDebugData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((dragonBones::CCArmatureDisplay const *)arg1)->getDebugData(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_getDebugData) + +static bool js_dragonBones_CCArmatureDisplay_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((dragonBones::CCArmatureDisplay const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_getSharedBufferOffset) + +static bool js_dragonBones_CCArmatureDisplay_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setColor) + +static bool js_dragonBones_CCArmatureDisplay_setDebugBonesEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugBonesEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setDebugBonesEnabled) + +static bool js_dragonBones_CCArmatureDisplay_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setBatchEnabled) + +static bool js_dragonBones_CCArmatureDisplay_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setAttachEnabled) + +static bool js_dragonBones_CCArmatureDisplay_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setOpacityModifyRGB) + +static bool js_dragonBones_CCArmatureDisplay_convertToRootSpace(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + float arg2 ; + float arg3 ; + cc::Vec2 *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(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::Vec2 *) &((dragonBones::CCArmatureDisplay const *)arg1)->convertToRootSpace(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_dragonBones_CCArmatureDisplay_convertToRootSpace) + +static bool js_dragonBones_CCArmatureDisplay_getRootDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::CCArmatureDisplay *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::CCArmatureDisplay *)(arg1)->getRootDisplay(); + + 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_dragonBones_CCArmatureDisplay_getRootDisplay) + +static bool js_dragonBones_CCArmatureDisplay_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setMaterial) + +static bool js_dragonBones_CCArmatureDisplay_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setRenderEntity) + +bool js_register_dragonBones_CCArmatureDisplay(se::Object* obj) { + auto* cls = se::Class::create("CCArmatureDisplay", obj, nullptr, _SE(js_new_dragonBones_CCArmatureDisplay)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("dbInit", _SE(js_dragonBones_CCArmatureDisplay_dbInit)); + cls->defineFunction("dbClear", _SE(js_dragonBones_CCArmatureDisplay_dbClear)); + cls->defineFunction("dbUpdate", _SE(js_dragonBones_CCArmatureDisplay_dbUpdate)); + cls->defineFunction("dbRender", _SE(js_dragonBones_CCArmatureDisplay_dbRender)); + cls->defineFunction("dispose", _SE(js_dragonBones_CCArmatureDisplay_dispose)); + cls->defineFunction("hasDBEventListener", _SE(js_dragonBones_CCArmatureDisplay_hasDBEventListener)); + cls->defineFunction("dispatchDBEvent", _SE(js_dragonBones_CCArmatureDisplay_dispatchDBEvent)); + cls->defineFunction("addDBEventListener", _SE(js_dragonBones_CCArmatureDisplay_addDBEventListener)); + cls->defineFunction("removeDBEventListener", _SE(js_dragonBones_CCArmatureDisplay_removeDBEventListener)); + cls->defineFunction("setDBEventCallback", _SE(js_dragonBones_CCArmatureDisplay_setDBEventCallback)); + cls->defineFunction("armature", _SE(js_dragonBones_CCArmatureDisplay_armature)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_CCArmatureDisplay_getAnimation)); + cls->defineFunction("getDebugData", _SE(js_dragonBones_CCArmatureDisplay_getDebugData)); + cls->defineFunction("getSharedBufferOffset", _SE(js_dragonBones_CCArmatureDisplay_getSharedBufferOffset)); + cls->defineFunction("setColor", _SE(js_dragonBones_CCArmatureDisplay_setColor)); + cls->defineFunction("setDebugBonesEnabled", _SE(js_dragonBones_CCArmatureDisplay_setDebugBonesEnabled)); + cls->defineFunction("setBatchEnabled", _SE(js_dragonBones_CCArmatureDisplay_setBatchEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_dragonBones_CCArmatureDisplay_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_dragonBones_CCArmatureDisplay_setOpacityModifyRGB)); + cls->defineFunction("convertToRootSpace", _SE(js_dragonBones_CCArmatureDisplay_convertToRootSpace)); + cls->defineFunction("getRootDisplay", _SE(js_dragonBones_CCArmatureDisplay_getRootDisplay)); + cls->defineFunction("setMaterial", _SE(js_dragonBones_CCArmatureDisplay_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_dragonBones_CCArmatureDisplay_setRenderEntity)); + + + cls->defineStaticFunction("create", _SE(js_dragonBones_CCArmatureDisplay_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCArmatureDisplay)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCArmatureDisplay_proto = cls->getProto(); + __jsb_dragonBones_CCArmatureDisplay_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCFactory_class = nullptr; +se::Object* __jsb_dragonBones_CCFactory_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCFactory) + +static bool js_dragonBones_CCFactory_isInit_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)dragonBones::CCFactory::isInit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_isInit_static) + +static bool js_dragonBones_CCFactory_getFactory_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::CCFactory *)dragonBones::CCFactory::getFactory(); + + 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_dragonBones_CCFactory_getFactory_static) + +static bool js_dragonBones_CCFactory_destroyFactory_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + dragonBones::CCFactory::destroyFactory(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_destroyFactory_static) + +static bool js_new_dragonBones_CCFactory(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::CCFactory *result; + result = (dragonBones::CCFactory *)new dragonBones::CCFactory(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_CCFactory, __jsb_dragonBones_CCFactory_class, js_delete_dragonBones_CCFactory) + +static bool js_dragonBones_CCFactory_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_update) + +static bool js_dragonBones_CCFactory_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_render) + +static bool js_dragonBones_CCFactory_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_stopSchedule) + +static bool js_delete_dragonBones_CCFactory(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCFactory) + +static bool js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::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_dragonBones_CCFactory_buildArmatureDisplay__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::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; +} + +static bool js_dragonBones_CCFactory_buildArmatureDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_buildArmatureDisplay) + +static bool js_dragonBones_CCFactory_getSoundEventManager(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::CCArmatureDisplay *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->getSoundEventManager(); + + 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_dragonBones_CCFactory_getSoundEventManager) + +static bool js_dragonBones_CCFactory_getClock_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::WorldClock *)dragonBones::CCFactory::getClock(); + + 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_dragonBones_CCFactory_getClock_static) + +static bool js_dragonBones_CCFactory_add(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->add(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_add) + +static bool js_dragonBones_CCFactory_remove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->remove(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_remove) + +static bool js_dragonBones_CCFactory_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_setTimeScale) + +static bool js_dragonBones_CCFactory_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_getTimeScale) + +static bool js_dragonBones_CCFactory_getDragonBones(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::DragonBones *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::DragonBones *)(arg1)->getDragonBones(); + + 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_dragonBones_CCFactory_getDragonBones) + +static bool js_dragonBones_CCFactory_getDragonBonesDataByUUID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::DragonBonesData *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(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 = (dragonBones::DragonBonesData *)(arg1)->getDragonBonesDataByUUID((std::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_dragonBones_CCFactory_getDragonBonesDataByUUID) + +static bool js_dragonBones_CCFactory_removeTextureAtlasDataByIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::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(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)->removeTextureAtlasDataByIndex((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_removeTextureAtlasDataByIndex) + +static bool js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesDataByUUID((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesDataByUUID((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_CCFactory_removeDragonBonesDataByUUID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_removeDragonBonesDataByUUID) + +static bool js_dragonBones_CCFactory_getTextureAtlasDataByIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::string temp2 ; + dragonBones::CCTextureAtlasData *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(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 = (dragonBones::CCTextureAtlasData *)((dragonBones::CCFactory const *)arg1)->getTextureAtlasDataByIndex((std::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_dragonBones_CCFactory_getTextureAtlasDataByIndex) + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + float arg4 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesDataByPath((std::string const &)*arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesDataByPath((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesDataByPath((std::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; +} + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_parseDragonBonesDataByPath) + +bool js_register_dragonBones_CCFactory(se::Object* obj) { + auto* cls = se::Class::create("CCFactory", obj, __jsb_dragonBones_BaseFactory_proto, _SE(js_new_dragonBones_CCFactory)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_dragonBones_CCFactory_update)); + cls->defineFunction("render", _SE(js_dragonBones_CCFactory_render)); + cls->defineFunction("stopSchedule", _SE(js_dragonBones_CCFactory_stopSchedule)); + cls->defineFunction("buildArmatureDisplay", _SE(js_dragonBones_CCFactory_buildArmatureDisplay)); + cls->defineFunction("getSoundEventManager", _SE(js_dragonBones_CCFactory_getSoundEventManager)); + cls->defineFunction("add", _SE(js_dragonBones_CCFactory_add)); + cls->defineFunction("remove", _SE(js_dragonBones_CCFactory_remove)); + cls->defineFunction("setTimeScale", _SE(js_dragonBones_CCFactory_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_dragonBones_CCFactory_getTimeScale)); + cls->defineFunction("getDragonBones", _SE(js_dragonBones_CCFactory_getDragonBones)); + cls->defineFunction("getDragonBonesDataByUUID", _SE(js_dragonBones_CCFactory_getDragonBonesDataByUUID)); + cls->defineFunction("removeTextureAtlasDataByIndex", _SE(js_dragonBones_CCFactory_removeTextureAtlasDataByIndex)); + cls->defineFunction("removeDragonBonesDataByUUID", _SE(js_dragonBones_CCFactory_removeDragonBonesDataByUUID)); + cls->defineFunction("getTextureAtlasDataByIndex", _SE(js_dragonBones_CCFactory_getTextureAtlasDataByIndex)); + cls->defineFunction("parseDragonBonesDataByPath", _SE(js_dragonBones_CCFactory_parseDragonBonesDataByPath)); + + + cls->defineStaticFunction("isInit", _SE(js_dragonBones_CCFactory_isInit_static)); + cls->defineStaticFunction("getFactory", _SE(js_dragonBones_CCFactory_getFactory_static)); + cls->defineStaticFunction("destroyFactory", _SE(js_dragonBones_CCFactory_destroyFactory_static)); + cls->defineStaticFunction("getClock", _SE(js_dragonBones_CCFactory_getClock_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCFactory)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCFactory_proto = cls->getProto(); + __jsb_dragonBones_CCFactory_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCSlot_class = nullptr; +se::Object* __jsb_dragonBones_CCSlot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCSlot) + +static bool js_delete_dragonBones_CCSlot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCSlot) + +static bool js_dragonBones_CCSlot_updateWorldMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCSlot *arg1 = (dragonBones::CCSlot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldMatrix(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCSlot_updateWorldMatrix) + +bool js_register_dragonBones_CCSlot(se::Object* obj) { + auto* cls = se::Class::create("CCSlot", obj, __jsb_dragonBones_Slot_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateWorldMatrix", _SE(js_dragonBones_CCSlot_updateWorldMatrix)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCSlot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCSlot_proto = cls->getProto(); + __jsb_dragonBones_CCSlot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCArmatureCacheDisplay_class = nullptr; +se::Object* __jsb_dragonBones_CCArmatureCacheDisplay_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureCacheDisplay) + +static bool js_new_dragonBones_CCArmatureCacheDisplay(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + bool arg4 ; + std::string temp1 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::CCArmatureCacheDisplay *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::CCArmatureCacheDisplay *)new dragonBones::CCArmatureCacheDisplay((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_CCArmatureCacheDisplay, __jsb_dragonBones_CCArmatureCacheDisplay_class, js_delete_dragonBones_CCArmatureCacheDisplay) + +static bool js_delete_dragonBones_CCArmatureCacheDisplay(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureCacheDisplay) + +static bool js_dragonBones_CCArmatureCacheDisplay_dispose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dispose(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_dispose) + +static bool js_dragonBones_CCArmatureCacheDisplay_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_update) + +static bool js_dragonBones_CCArmatureCacheDisplay_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_render) + +static bool js_dragonBones_CCArmatureCacheDisplay_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setTimeScale) + +static bool js_dragonBones_CCArmatureCacheDisplay_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((dragonBones::CCArmatureCacheDisplay const *)arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_getTimeScale) + +static bool js_dragonBones_CCArmatureCacheDisplay_beginSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSchedule(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_beginSchedule) + +static bool js_dragonBones_CCArmatureCacheDisplay_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_stopSchedule) + +static bool js_dragonBones_CCArmatureCacheDisplay_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_onEnable) + +static bool js_dragonBones_CCArmatureCacheDisplay_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_onDisable) + +static bool js_dragonBones_CCArmatureCacheDisplay_armature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::CCArmatureCacheDisplay const *)arg1)->getArmature(); + + 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_dragonBones_CCArmatureCacheDisplay_armature) + +static bool js_dragonBones_CCArmatureCacheDisplay_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + dragonBones::Animation *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Animation *)((dragonBones::CCArmatureCacheDisplay const *)arg1)->getAnimation(); + + 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_dragonBones_CCArmatureCacheDisplay_getAnimation) + +static bool js_dragonBones_CCArmatureCacheDisplay_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setColor) + +static bool js_dragonBones_CCArmatureCacheDisplay_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setBatchEnabled) + +static bool js_dragonBones_CCArmatureCacheDisplay_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setAttachEnabled) + +static bool js_dragonBones_CCArmatureCacheDisplay_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setOpacityModifyRGB) + +static bool js_dragonBones_CCArmatureCacheDisplay_setDBEventCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + dragonBones::CCArmatureCacheDisplay::dbEventCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDBEventCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setDBEventCallback) + +static bool js_dragonBones_CCArmatureCacheDisplay_addDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addDBEventListener((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_addDBEventListener) + +static bool js_dragonBones_CCArmatureCacheDisplay_removeDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeDBEventListener((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_removeDBEventListener) + +static bool js_dragonBones_CCArmatureCacheDisplay_dispatchDBEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + dragonBones::EventObject *arg3 = (dragonBones::EventObject *) NULL ; + std::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(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)->dispatchDBEvent((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_dispatchDBEvent) + +static bool js_dragonBones_CCArmatureCacheDisplay_playAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::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(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)->playAnimation((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_playAnimation) + +static bool js_dragonBones_CCArmatureCacheDisplay_updateAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateAnimationCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_updateAnimationCache) + +static bool js_dragonBones_CCArmatureCacheDisplay_updateAllAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateAllAnimationCache(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_updateAllAnimationCache) + +static bool js_dragonBones_CCArmatureCacheDisplay_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((dragonBones::CCArmatureCacheDisplay const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_getSharedBufferOffset) + +static bool js_dragonBones_CCArmatureCacheDisplay_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setMaterial) + +static bool js_dragonBones_CCArmatureCacheDisplay_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setRenderEntity) + +bool js_register_dragonBones_CCArmatureCacheDisplay(se::Object* obj) { + auto* cls = se::Class::create("CCArmatureCacheDisplay", obj, nullptr, _SE(js_new_dragonBones_CCArmatureCacheDisplay)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("dispose", _SE(js_dragonBones_CCArmatureCacheDisplay_dispose)); + cls->defineFunction("update", _SE(js_dragonBones_CCArmatureCacheDisplay_update)); + cls->defineFunction("render", _SE(js_dragonBones_CCArmatureCacheDisplay_render)); + cls->defineFunction("setTimeScale", _SE(js_dragonBones_CCArmatureCacheDisplay_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_dragonBones_CCArmatureCacheDisplay_getTimeScale)); + cls->defineFunction("beginSchedule", _SE(js_dragonBones_CCArmatureCacheDisplay_beginSchedule)); + cls->defineFunction("stopSchedule", _SE(js_dragonBones_CCArmatureCacheDisplay_stopSchedule)); + cls->defineFunction("onEnable", _SE(js_dragonBones_CCArmatureCacheDisplay_onEnable)); + cls->defineFunction("onDisable", _SE(js_dragonBones_CCArmatureCacheDisplay_onDisable)); + cls->defineFunction("armature", _SE(js_dragonBones_CCArmatureCacheDisplay_armature)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_CCArmatureCacheDisplay_getAnimation)); + cls->defineFunction("setColor", _SE(js_dragonBones_CCArmatureCacheDisplay_setColor)); + cls->defineFunction("setBatchEnabled", _SE(js_dragonBones_CCArmatureCacheDisplay_setBatchEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_dragonBones_CCArmatureCacheDisplay_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_dragonBones_CCArmatureCacheDisplay_setOpacityModifyRGB)); + cls->defineFunction("setDBEventCallback", _SE(js_dragonBones_CCArmatureCacheDisplay_setDBEventCallback)); + cls->defineFunction("addDBEventListener", _SE(js_dragonBones_CCArmatureCacheDisplay_addDBEventListener)); + cls->defineFunction("removeDBEventListener", _SE(js_dragonBones_CCArmatureCacheDisplay_removeDBEventListener)); + cls->defineFunction("dispatchDBEvent", _SE(js_dragonBones_CCArmatureCacheDisplay_dispatchDBEvent)); + cls->defineFunction("playAnimation", _SE(js_dragonBones_CCArmatureCacheDisplay_playAnimation)); + cls->defineFunction("updateAnimationCache", _SE(js_dragonBones_CCArmatureCacheDisplay_updateAnimationCache)); + cls->defineFunction("updateAllAnimationCache", _SE(js_dragonBones_CCArmatureCacheDisplay_updateAllAnimationCache)); + cls->defineFunction("getSharedBufferOffset", _SE(js_dragonBones_CCArmatureCacheDisplay_getSharedBufferOffset)); + cls->defineFunction("setMaterial", _SE(js_dragonBones_CCArmatureCacheDisplay_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_dragonBones_CCArmatureCacheDisplay_setRenderEntity)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCArmatureCacheDisplay)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCArmatureCacheDisplay_proto = cls->getProto(); + __jsb_dragonBones_CCArmatureCacheDisplay_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_ArmatureCache_class = nullptr; +se::Object* __jsb_dragonBones_ArmatureCache_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCache) + +static bool js_new_dragonBones_ArmatureCache(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp1 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::ArmatureCache *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::ArmatureCache *)new dragonBones::ArmatureCache((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_ArmatureCache, __jsb_dragonBones_ArmatureCache_class, js_delete_dragonBones_ArmatureCache) + +static bool js_delete_dragonBones_ArmatureCache(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCache) + +static bool js_dragonBones_ArmatureCache_updateToFrame__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->updateToFrame((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_ArmatureCache_updateToFrame__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->updateToFrame((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_ArmatureCache_updateToFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_ArmatureCache_updateToFrame__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_ArmatureCache_updateToFrame__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCache_updateToFrame) + +static bool js_dragonBones_ArmatureCache_buildAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureCache::AnimationData *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(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 = (dragonBones::ArmatureCache::AnimationData *)(arg1)->buildAnimationData((std::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_dragonBones_ArmatureCache_buildAnimationData) + +static bool js_dragonBones_ArmatureCache_getAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureCache::AnimationData *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(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 = (dragonBones::ArmatureCache::AnimationData *)(arg1)->getAnimationData((std::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_dragonBones_ArmatureCache_getAnimationData) + +static bool js_dragonBones_ArmatureCache_getArmatureDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + dragonBones::CCArmatureDisplay *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::CCArmatureDisplay *)(arg1)->getArmatureDisplay(); + + 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_dragonBones_ArmatureCache_getArmatureDisplay) + +static bool js_dragonBones_ArmatureCache_resetAllAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetAllAnimationData(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCache_resetAllAnimationData) + +static bool js_dragonBones_ArmatureCache_resetAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resetAnimationData((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCache_resetAnimationData) + +bool js_register_dragonBones_ArmatureCache(se::Object* obj) { + auto* cls = se::Class::create("ArmatureCache", obj, nullptr, _SE(js_new_dragonBones_ArmatureCache)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateToFrame", _SE(js_dragonBones_ArmatureCache_updateToFrame)); + cls->defineFunction("buildAnimationData", _SE(js_dragonBones_ArmatureCache_buildAnimationData)); + cls->defineFunction("getAnimationData", _SE(js_dragonBones_ArmatureCache_getAnimationData)); + cls->defineFunction("getArmatureDisplay", _SE(js_dragonBones_ArmatureCache_getArmatureDisplay)); + cls->defineFunction("resetAllAnimationData", _SE(js_dragonBones_ArmatureCache_resetAllAnimationData)); + cls->defineFunction("resetAnimationData", _SE(js_dragonBones_ArmatureCache_resetAnimationData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_ArmatureCache)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_ArmatureCache_proto = cls->getProto(); + __jsb_dragonBones_ArmatureCache_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_ArmatureCacheMgr_class = nullptr; +se::Object* __jsb_dragonBones_ArmatureCacheMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCacheMgr) + +static bool js_dragonBones_ArmatureCacheMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCacheMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::ArmatureCacheMgr *)dragonBones::ArmatureCacheMgr::getInstance(); + + 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_dragonBones_ArmatureCacheMgr_getInstance_static) + +static bool js_dragonBones_ArmatureCacheMgr_destroyInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + dragonBones::ArmatureCacheMgr::destroyInstance(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCacheMgr_destroyInstance_static) + +static bool js_dragonBones_ArmatureCacheMgr_removeArmatureCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCacheMgr *arg1 = (dragonBones::ArmatureCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeArmatureCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCacheMgr_removeArmatureCache) + +static bool js_dragonBones_ArmatureCacheMgr_buildArmatureCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCacheMgr *arg1 = (dragonBones::ArmatureCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::ArmatureCache *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::ArmatureCache *)(arg1)->buildArmatureCache((std::string const &)*arg2,(std::string const &)*arg3,(std::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; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCacheMgr_buildArmatureCache) + +static bool js_new_dragonBones_ArmatureCacheMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::ArmatureCacheMgr *result; + result = (dragonBones::ArmatureCacheMgr *)new dragonBones::ArmatureCacheMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_ArmatureCacheMgr, __jsb_dragonBones_ArmatureCacheMgr_class, js_delete_dragonBones_ArmatureCacheMgr) + +static bool js_delete_dragonBones_ArmatureCacheMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCacheMgr) + +bool js_register_dragonBones_ArmatureCacheMgr(se::Object* obj) { + auto* cls = se::Class::create("ArmatureCacheMgr", obj, nullptr, _SE(js_new_dragonBones_ArmatureCacheMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("removeArmatureCache", _SE(js_dragonBones_ArmatureCacheMgr_removeArmatureCache)); + cls->defineFunction("buildArmatureCache", _SE(js_dragonBones_ArmatureCacheMgr_buildArmatureCache)); + + + cls->defineStaticFunction("getInstance", _SE(js_dragonBones_ArmatureCacheMgr_getInstance_static)); + cls->defineStaticFunction("destroyInstance", _SE(js_dragonBones_ArmatureCacheMgr_destroyInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_ArmatureCacheMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_ArmatureCacheMgr_proto = cls->getProto(); + __jsb_dragonBones_ArmatureCacheMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_dragonbones(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("dragonBones", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("dragonBones", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_dragonBones_Rectangle(ns); + js_register_dragonBones_Transform(ns); + js_register_dragonBones_Matrix(ns); + js_register_dragonBones_BaseObject(ns); + js_register_dragonBones_EventObject(ns); + js_register_dragonBones_BaseFactory(ns); + js_register_dragonBones_BuildArmaturePackage(ns); + js_register_dragonBones_DragonBonesData(ns); + js_register_dragonBones_TextureAtlasData(ns); + js_register_dragonBones_TextureData(ns); + js_register_dragonBones_ArmatureData(ns); + js_register_dragonBones_BoneData(ns); + js_register_dragonBones_SlotData(ns); + js_register_dragonBones_SkinData(ns); + js_register_dragonBones_AnimationData(ns); + js_register_dragonBones_TimelineData(ns); + js_register_dragonBones_WorldClock(ns); + js_register_dragonBones_Animation(ns); + js_register_dragonBones_AnimationState(ns); + js_register_dragonBones_BonePose(ns); + js_register_dragonBones_BlendState(ns); + js_register_dragonBones_TransformObject(ns); + js_register_dragonBones_Slot(ns); + js_register_dragonBones_Bone(ns); + js_register_dragonBones_Armature(ns); + js_register_dragonBones_CCArmatureDisplay(ns); + js_register_dragonBones_CCFactory(ns); + js_register_dragonBones_CCSlot(ns); + js_register_dragonBones_CCArmatureCacheDisplay(ns); + js_register_dragonBones_ArmatureCache(ns); + js_register_dragonBones_ArmatureCacheMgr(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_dragonbones_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_dragonbones_auto.h new file mode 100644 index 0000000000..ef6df2be46 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_dragonbones_auto.h @@ -0,0 +1,199 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "editor-support/dragonbones-creator-support/CCDragonBonesHeaders.h" + + + +bool register_all_dragonbones(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Rectangle); +extern se::Object *__jsb_dragonBones_Rectangle_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Rectangle_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Transform); +extern se::Object *__jsb_dragonBones_Transform_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Transform_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Matrix); +extern se::Object *__jsb_dragonBones_Matrix_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Matrix_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BaseObject); +extern se::Object *__jsb_dragonBones_BaseObject_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BaseObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::EventObject); +extern se::Object *__jsb_dragonBones_EventObject_proto; // NOLINT +extern se::Class * __jsb_dragonBones_EventObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BaseFactory); +extern se::Object *__jsb_dragonBones_BaseFactory_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BaseFactory_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BuildArmaturePackage); +extern se::Object *__jsb_dragonBones_BuildArmaturePackage_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BuildArmaturePackage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::DragonBonesData); +extern se::Object *__jsb_dragonBones_DragonBonesData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_DragonBonesData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TextureAtlasData); +extern se::Object *__jsb_dragonBones_TextureAtlasData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TextureAtlasData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TextureData); +extern se::Object *__jsb_dragonBones_TextureData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TextureData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::ArmatureData); +extern se::Object *__jsb_dragonBones_ArmatureData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_ArmatureData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BoneData); +extern se::Object *__jsb_dragonBones_BoneData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BoneData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::SlotData); +extern se::Object *__jsb_dragonBones_SlotData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_SlotData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::SkinData); +extern se::Object *__jsb_dragonBones_SkinData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_SkinData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::AnimationData); +extern se::Object *__jsb_dragonBones_AnimationData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_AnimationData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TimelineData); +extern se::Object *__jsb_dragonBones_TimelineData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TimelineData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::WorldClock); +extern se::Object *__jsb_dragonBones_WorldClock_proto; // NOLINT +extern se::Class * __jsb_dragonBones_WorldClock_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Animation); +extern se::Object *__jsb_dragonBones_Animation_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Animation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::AnimationState); +extern se::Object *__jsb_dragonBones_AnimationState_proto; // NOLINT +extern se::Class * __jsb_dragonBones_AnimationState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BonePose); +extern se::Object *__jsb_dragonBones_BonePose_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BonePose_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BlendState); +extern se::Object *__jsb_dragonBones_BlendState_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BlendState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TransformObject); +extern se::Object *__jsb_dragonBones_TransformObject_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TransformObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Slot); +extern se::Object *__jsb_dragonBones_Slot_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Slot_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Bone); +extern se::Object *__jsb_dragonBones_Bone_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Bone_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Armature); +extern se::Object *__jsb_dragonBones_Armature_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Armature_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCArmatureDisplay); +extern se::Object *__jsb_dragonBones_CCArmatureDisplay_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCArmatureDisplay_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCFactory); +extern se::Object *__jsb_dragonBones_CCFactory_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCFactory_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCSlot); +extern se::Object *__jsb_dragonBones_CCSlot_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCSlot_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCArmatureCacheDisplay); +extern se::Object *__jsb_dragonBones_CCArmatureCacheDisplay_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCArmatureCacheDisplay_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::ArmatureCache); +extern se::Object *__jsb_dragonBones_ArmatureCache_proto; // NOLINT +extern se::Class * __jsb_dragonBones_ArmatureCache_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::ArmatureCacheMgr); +extern se::Object *__jsb_dragonBones_ArmatureCacheMgr_proto; // NOLINT +extern se::Class * __jsb_dragonBones_ArmatureCacheMgr_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_editor_support_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_editor_support_auto.cpp new file mode 100644 index 0000000000..cc832ea39e --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_editor_support_auto.cpp @@ -0,0 +1,1159 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_editor_support_auto.h" + + + +se::Class* __jsb_cc_middleware_Texture2D_class = nullptr; +se::Object* __jsb_cc_middleware_Texture2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_Texture2D) + +static bool js_new_cc_middleware_Texture2D(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::middleware::Texture2D *result; + result = (cc::middleware::Texture2D *)new cc::middleware::Texture2D(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_Texture2D, __jsb_cc_middleware_Texture2D_class, js_delete_cc_middleware_Texture2D) + +static bool js_delete_cc_middleware_Texture2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_Texture2D) + +static bool js_cc_middleware_Texture2D_getPixelsWide(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::middleware::Texture2D const *)arg1)->getPixelsWide(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_getPixelsWide) + +static bool js_cc_middleware_Texture2D_getPixelsHigh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::middleware::Texture2D const *)arg1)->getPixelsHigh(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_getPixelsHigh) + +static bool js_cc_middleware_Texture2D_getRealTextureIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::middleware::Texture2D const *)arg1)->getRealTextureIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_getRealTextureIndex) + +static bool js_cc_middleware_Texture2D_setPixelsWide(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPixelsWide(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setPixelsWide) + +static bool js_cc_middleware_Texture2D_setPixelsHigh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPixelsHigh(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setPixelsHigh) + +static bool js_cc_middleware_Texture2D_setRealTextureIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRealTextureIndex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setRealTextureIndex) + +static bool js_cc_middleware_Texture2D_setTexParamCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + cc::middleware::Texture2D::texParamCallback *arg2 = 0 ; + cc::middleware::Texture2D::texParamCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setTexParamCallback((cc::middleware::Texture2D::texParamCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setTexParamCallback) + +static bool js_cc_middleware_Texture2D_setRealTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRealTexture(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setRealTexture) + +static bool js_cc_middleware_Texture2D_getRealTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((cc::middleware::Texture2D const *)arg1)->getRealTexture(); + + 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_middleware_Texture2D_getRealTexture) + +bool js_register_cc_middleware_Texture2D(se::Object* obj) { + auto* cls = se::Class::create("Texture2D", obj, nullptr, _SE(js_new_cc_middleware_Texture2D)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getPixelsWide", _SE(js_cc_middleware_Texture2D_getPixelsWide)); + cls->defineFunction("getPixelsHigh", _SE(js_cc_middleware_Texture2D_getPixelsHigh)); + cls->defineFunction("getRealTextureIndex", _SE(js_cc_middleware_Texture2D_getRealTextureIndex)); + cls->defineFunction("setPixelsWide", _SE(js_cc_middleware_Texture2D_setPixelsWide)); + cls->defineFunction("setPixelsHigh", _SE(js_cc_middleware_Texture2D_setPixelsHigh)); + cls->defineFunction("setRealTextureIndex", _SE(js_cc_middleware_Texture2D_setRealTextureIndex)); + cls->defineFunction("setTexParamCallback", _SE(js_cc_middleware_Texture2D_setTexParamCallback)); + cls->defineFunction("setRealTexture", _SE(js_cc_middleware_Texture2D_setRealTexture)); + cls->defineFunction("getRealTexture", _SE(js_cc_middleware_Texture2D_getRealTexture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_Texture2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_Texture2D_proto = cls->getProto(); + __jsb_cc_middleware_Texture2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_middleware_SpriteFrame_class = nullptr; +se::Object* __jsb_cc_middleware_SpriteFrame_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_SpriteFrame) + +static bool js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg2 = 0 ; + cc::Rect temp2 ; + cc::middleware::SpriteFrame *result = 0 ; + + + 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::middleware::SpriteFrame *)cc::middleware::SpriteFrame::createWithTexture(arg1,(cc::Rect 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; +} + +static bool js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg2 = 0 ; + bool arg3 ; + cc::Vec2 *arg4 = 0 ; + cc::Size *arg5 = 0 ; + cc::Rect temp2 ; + cc::Vec2 temp4 ; + cc::Size temp5 ; + cc::middleware::SpriteFrame *result = 0 ; + + + 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; + + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (cc::middleware::SpriteFrame *)cc::middleware::SpriteFrame::createWithTexture(arg1,(cc::Rect const &)*arg2,arg3,(cc::Vec2 const &)*arg4,(cc::Size const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_middleware_SpriteFrame_createWithTexture_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_middleware_SpriteFrame_createWithTexture_static) + +static bool js_new_cc_middleware_SpriteFrame(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::middleware::SpriteFrame *result; + result = (cc::middleware::SpriteFrame *)new cc::middleware::SpriteFrame(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_SpriteFrame, __jsb_cc_middleware_SpriteFrame_class, js_delete_cc_middleware_SpriteFrame) + +static bool js_delete_cc_middleware_SpriteFrame(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_SpriteFrame) + +static bool js_cc_middleware_SpriteFrame_initWithTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *arg2 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg3 = 0 ; + cc::Rect temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->initWithTexture(arg2,(cc::Rect const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_middleware_SpriteFrame_initWithTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *arg2 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg3 = 0 ; + bool arg4 ; + cc::Vec2 *arg5 = 0 ; + cc::Size *arg6 = 0 ; + cc::Rect temp3 ; + cc::Vec2 temp5 ; + cc::Size temp6 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (bool)(arg1)->initWithTexture(arg2,(cc::Rect const &)*arg3,arg4,(cc::Vec2 const &)*arg5,(cc::Size const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_middleware_SpriteFrame_initWithTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_middleware_SpriteFrame_initWithTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_middleware_SpriteFrame_initWithTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_middleware_SpriteFrame_initWithTexture) + +static bool js_cc_middleware_SpriteFrame_getTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *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(s); + if (nullptr == arg1) return true; + result = (cc::middleware::Texture2D *)(arg1)->getTexture(); + + 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_middleware_SpriteFrame_getTexture) + +static bool js_cc_middleware_SpriteFrame_setTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *arg2 = (cc::middleware::Texture2D *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTexture(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_SpriteFrame_setTexture) + +bool js_register_cc_middleware_SpriteFrame(se::Object* obj) { + auto* cls = se::Class::create("SpriteFrame", obj, nullptr, _SE(js_new_cc_middleware_SpriteFrame)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithTexture", _SE(js_cc_middleware_SpriteFrame_initWithTexture)); + cls->defineFunction("getTexture", _SE(js_cc_middleware_SpriteFrame_getTexture)); + cls->defineFunction("setTexture", _SE(js_cc_middleware_SpriteFrame_setTexture)); + + + cls->defineStaticFunction("createWithTexture", _SE(js_cc_middleware_SpriteFrame_createWithTexture_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_SpriteFrame)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_SpriteFrame_proto = cls->getProto(); + __jsb_cc_middleware_SpriteFrame_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_middleware_SharedBufferManager_class = nullptr; +se::Object* __jsb_cc_middleware_SharedBufferManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_SharedBufferManager) + +static bool js_new_cc_middleware_SharedBufferManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + se::Object::TypedArrayType arg1 ; + cc::middleware::SharedBufferManager *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::middleware::SharedBufferManager *)new cc::middleware::SharedBufferManager(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_SharedBufferManager, __jsb_cc_middleware_SharedBufferManager_class, js_delete_cc_middleware_SharedBufferManager) + +static bool js_delete_cc_middleware_SharedBufferManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_SharedBufferManager) + +static bool js_cc_middleware_SharedBufferManager_setResizeCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SharedBufferManager *arg1 = (cc::middleware::SharedBufferManager *) NULL ; + cc::middleware::SharedBufferManager::resizeCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setResizeCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_SharedBufferManager_setResizeCallback) + +static bool js_cc_middleware_SharedBufferManager_getSharedBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SharedBufferManager *arg1 = (cc::middleware::SharedBufferManager *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::middleware::SharedBufferManager const *)arg1)->getSharedBuffer(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_SharedBufferManager_getSharedBuffer) + +bool js_register_cc_middleware_SharedBufferManager(se::Object* obj) { + auto* cls = se::Class::create("SharedBufferManager", obj, nullptr, _SE(js_new_cc_middleware_SharedBufferManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setResizeCallback", _SE(js_cc_middleware_SharedBufferManager_setResizeCallback)); + cls->defineFunction("getSharedBuffer", _SE(js_cc_middleware_SharedBufferManager_getSharedBuffer)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_SharedBufferManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_SharedBufferManager_proto = cls->getProto(); + __jsb_cc_middleware_SharedBufferManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_middleware_MiddlewareManager_class = nullptr; +se::Object* __jsb_cc_middleware_MiddlewareManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_MiddlewareManager) + +static bool js_cc_middleware_MiddlewareManager_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::middleware::MiddlewareManager *)cc::middleware::MiddlewareManager::getInstance(); + + 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_middleware_MiddlewareManager_getInstance_static) + +static bool js_cc_middleware_MiddlewareManager_destroyInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::middleware::MiddlewareManager::destroyInstance(); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_destroyInstance_static) + +static bool js_cc_middleware_MiddlewareManager_generateModuleID_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint8_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = cc::middleware::MiddlewareManager::generateModuleID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_generateModuleID_static) + +static bool js_cc_middleware_MiddlewareManager_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_update) + +static bool js_cc_middleware_MiddlewareManager_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_render) + +static bool js_cc_middleware_MiddlewareManager_getVBTypedArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + int arg3 ; + se_object_ptr result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getVBTypedArray(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getVBTypedArray) + +static bool js_cc_middleware_MiddlewareManager_getIBTypedArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + int arg3 ; + se_object_ptr result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getIBTypedArray(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getIBTypedArray) + +static bool js_cc_middleware_MiddlewareManager_getBufferCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + std::size_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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getBufferCount(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getBufferCount) + +static bool js_cc_middleware_MiddlewareManager_getVBTypedArrayLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + std::size_t arg3 ; + std::size_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(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 = (arg1)->getVBTypedArrayLength(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getVBTypedArrayLength) + +static bool js_cc_middleware_MiddlewareManager_getIBTypedArrayLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + std::size_t arg3 ; + std::size_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(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 = (arg1)->getIBTypedArrayLength(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getIBTypedArrayLength) + +static bool js_cc_middleware_MiddlewareManager_getRenderInfoMgr(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + cc::middleware::SharedBufferManager *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(s); + if (nullptr == arg1) return true; + result = (cc::middleware::SharedBufferManager *)(arg1)->getRenderInfoMgr(); + + 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_middleware_MiddlewareManager_getRenderInfoMgr) + +static bool js_cc_middleware_MiddlewareManager_getAttachInfoMgr(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + cc::middleware::SharedBufferManager *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(s); + if (nullptr == arg1) return true; + result = (cc::middleware::SharedBufferManager *)(arg1)->getAttachInfoMgr(); + + 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_middleware_MiddlewareManager_getAttachInfoMgr) + +static bool js_new_cc_middleware_MiddlewareManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::middleware::MiddlewareManager *result; + result = (cc::middleware::MiddlewareManager *)new cc::middleware::MiddlewareManager(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_MiddlewareManager, __jsb_cc_middleware_MiddlewareManager_class, js_delete_cc_middleware_MiddlewareManager) + +static bool js_delete_cc_middleware_MiddlewareManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_MiddlewareManager) + +bool js_register_cc_middleware_MiddlewareManager(se::Object* obj) { + auto* cls = se::Class::create("MiddlewareManager", obj, nullptr, _SE(js_new_cc_middleware_MiddlewareManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_middleware_MiddlewareManager_update)); + cls->defineFunction("render", _SE(js_cc_middleware_MiddlewareManager_render)); + cls->defineFunction("getVBTypedArray", _SE(js_cc_middleware_MiddlewareManager_getVBTypedArray)); + cls->defineFunction("getIBTypedArray", _SE(js_cc_middleware_MiddlewareManager_getIBTypedArray)); + cls->defineFunction("getBufferCount", _SE(js_cc_middleware_MiddlewareManager_getBufferCount)); + cls->defineFunction("getVBTypedArrayLength", _SE(js_cc_middleware_MiddlewareManager_getVBTypedArrayLength)); + cls->defineFunction("getIBTypedArrayLength", _SE(js_cc_middleware_MiddlewareManager_getIBTypedArrayLength)); + cls->defineFunction("getRenderInfoMgr", _SE(js_cc_middleware_MiddlewareManager_getRenderInfoMgr)); + cls->defineFunction("getAttachInfoMgr", _SE(js_cc_middleware_MiddlewareManager_getAttachInfoMgr)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_middleware_MiddlewareManager_getInstance_static)); + cls->defineStaticFunction("destroyInstance", _SE(js_cc_middleware_MiddlewareManager_destroyInstance_static)); + cls->defineStaticFunction("generateModuleID", _SE(js_cc_middleware_MiddlewareManager_generateModuleID_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_MiddlewareManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_MiddlewareManager_proto = cls->getProto(); + __jsb_cc_middleware_MiddlewareManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_editor_support(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("middleware", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("middleware", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_middleware_Texture2D(ns); + js_register_cc_middleware_SpriteFrame(ns); + js_register_cc_middleware_SharedBufferManager(ns); + js_register_cc_middleware_MiddlewareManager(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_editor_support_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_editor_support_auto.h new file mode 100644 index 0000000000..e788ecba6b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_editor_support_auto.h @@ -0,0 +1,67 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "editor-support/middleware-adapter.h" +#include "editor-support/MiddlewareManager.h" +#include "editor-support/SharedBufferManager.h" + + + + +bool register_all_editor_support(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::Texture2D); +extern se::Object *__jsb_cc_middleware_Texture2D_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_Texture2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::SpriteFrame); +extern se::Object *__jsb_cc_middleware_SpriteFrame_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_SpriteFrame_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::SharedBufferManager); +extern se::Object *__jsb_cc_middleware_SharedBufferManager_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_SharedBufferManager_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::MiddlewareManager); +extern se::Object *__jsb_cc_middleware_MiddlewareManager_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_MiddlewareManager_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_extension_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_extension_auto.cpp new file mode 100644 index 0000000000..6486aeb598 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_extension_auto.cpp @@ -0,0 +1,2522 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_extension_auto.h" + + + +se::Class* __jsb_cc_extension_EventAssetsManagerEx_class = nullptr; +se::Object* __jsb_cc_extension_EventAssetsManagerEx_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_EventAssetsManagerEx) + +static bool js_cc_extension_EventAssetsManager_getEventCode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::extension::EventAssetsManagerEx::EventCode)((cc::extension::EventAssetsManagerEx const *)arg1)->getEventCode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getEventCode) + +static bool js_cc_extension_EventAssetsManager_getCURLECode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getCURLECode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getCURLECode) + +static bool js_cc_extension_EventAssetsManager_getCURLMCode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getCURLMCode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getCURLMCode) + +static bool js_cc_extension_EventAssetsManager_getMessage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + std::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::extension::EventAssetsManagerEx const *)arg1)->getMessage(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getMessage) + +static bool js_cc_extension_EventAssetsManager_getAssetId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + std::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::extension::EventAssetsManagerEx const *)arg1)->getAssetId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getAssetId) + +static bool js_cc_extension_EventAssetsManager_getAssetsManagerEx(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx *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(s); + if (nullptr == arg1) return true; + result = (cc::extension::AssetsManagerEx *)((cc::extension::EventAssetsManagerEx const *)arg1)->getAssetsManagerEx(); + + 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_extension_EventAssetsManager_getAssetsManagerEx) + +static bool js_cc_extension_EventAssetsManager_isResuming(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::EventAssetsManagerEx const *)arg1)->isResuming(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_isResuming) + +static bool js_cc_extension_EventAssetsManager_getPercent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::extension::EventAssetsManagerEx const *)arg1)->getPercent(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getPercent) + +static bool js_cc_extension_EventAssetsManager_getPercentByFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::extension::EventAssetsManagerEx const *)arg1)->getPercentByFile(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getPercentByFile) + +static bool js_cc_extension_EventAssetsManager_getDownloadedBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::EventAssetsManagerEx const *)arg1)->getDownloadedBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getDownloadedBytes) + +static bool js_cc_extension_EventAssetsManager_getTotalBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::EventAssetsManagerEx const *)arg1)->getTotalBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getTotalBytes) + +static bool js_cc_extension_EventAssetsManager_getDownloadedFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getDownloadedFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getDownloadedFiles) + +static bool js_cc_extension_EventAssetsManager_getTotalFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getTotalFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getTotalFiles) + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string arg5 ; + int arg6 ; + int arg7 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string arg5 ; + int arg6 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string arg5 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 7) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 6) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of EventAssetsManager"); + return false; +} +SE_BIND_CTOR(js_new_cc_extension_EventAssetsManagerEx, __jsb_cc_extension_EventAssetsManagerEx_class, js_delete_cc_extension_EventAssetsManagerEx) + +static bool js_delete_cc_extension_EventAssetsManagerEx(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_EventAssetsManagerEx) + +bool js_register_cc_extension_EventAssetsManagerEx(se::Object* obj) { + auto* cls = se::Class::create("EventAssetsManager", obj, nullptr, _SE(js_new_cc_extension_EventAssetsManagerEx)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getEventCode", _SE(js_cc_extension_EventAssetsManager_getEventCode)); + cls->defineFunction("getCURLECode", _SE(js_cc_extension_EventAssetsManager_getCURLECode)); + cls->defineFunction("getCURLMCode", _SE(js_cc_extension_EventAssetsManager_getCURLMCode)); + cls->defineFunction("getMessage", _SE(js_cc_extension_EventAssetsManager_getMessage)); + cls->defineFunction("getAssetId", _SE(js_cc_extension_EventAssetsManager_getAssetId)); + cls->defineFunction("getAssetsManagerEx", _SE(js_cc_extension_EventAssetsManager_getAssetsManagerEx)); + cls->defineFunction("isResuming", _SE(js_cc_extension_EventAssetsManager_isResuming)); + cls->defineFunction("getPercent", _SE(js_cc_extension_EventAssetsManager_getPercent)); + cls->defineFunction("getPercentByFile", _SE(js_cc_extension_EventAssetsManager_getPercentByFile)); + cls->defineFunction("getDownloadedBytes", _SE(js_cc_extension_EventAssetsManager_getDownloadedBytes)); + cls->defineFunction("getTotalBytes", _SE(js_cc_extension_EventAssetsManager_getTotalBytes)); + cls->defineFunction("getDownloadedFiles", _SE(js_cc_extension_EventAssetsManager_getDownloadedFiles)); + cls->defineFunction("getTotalFiles", _SE(js_cc_extension_EventAssetsManager_getTotalFiles)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_EventAssetsManagerEx)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_EventAssetsManagerEx_proto = cls->getProto(); + __jsb_cc_extension_EventAssetsManagerEx_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_DownloadUnit_class = nullptr; +se::Object* __jsb_cc_extension_DownloadUnit_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_DownloadUnit) + +static bool js_cc_extension_DownloadUnit_srcUrl_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcUrl, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_srcUrl_set) + +static bool js_cc_extension_DownloadUnit_srcUrl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcUrl, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcUrl, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_srcUrl_get) + +static bool js_cc_extension_DownloadUnit_storagePath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storagePath, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_storagePath_set) + +static bool js_cc_extension_DownloadUnit_storagePath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storagePath, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storagePath, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_storagePath_get) + +static bool js_cc_extension_DownloadUnit_customId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->customId, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_customId_set) + +static bool js_cc_extension_DownloadUnit_customId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->customId, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->customId, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_customId_get) + +static bool js_cc_extension_DownloadUnit_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_size_set) + +static bool js_cc_extension_DownloadUnit_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_size_get) + +static bool js_new_cc_extension_DownloadUnit(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::extension::DownloadUnit *result; + result = (cc::extension::DownloadUnit *)new cc::extension::DownloadUnit(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_extension_DownloadUnit, __jsb_cc_extension_DownloadUnit_class, js_delete_cc_extension_DownloadUnit) + +static bool js_delete_cc_extension_DownloadUnit(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_DownloadUnit) + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::DownloadUnit * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcUrl", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcUrl), ctx); + } + + + json->getProperty("storagePath", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->storagePath), ctx); + } + + + json->getProperty("customId", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->customId), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + return ok; +} + + +bool js_register_cc_extension_DownloadUnit(se::Object* obj) { + auto* cls = se::Class::create("DownloadUnit", obj, nullptr, _SE(js_new_cc_extension_DownloadUnit)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcUrl", _SE(js_cc_extension_DownloadUnit_srcUrl_get), _SE(js_cc_extension_DownloadUnit_srcUrl_set)); + cls->defineProperty("storagePath", _SE(js_cc_extension_DownloadUnit_storagePath_get), _SE(js_cc_extension_DownloadUnit_storagePath_set)); + cls->defineProperty("customId", _SE(js_cc_extension_DownloadUnit_customId_get), _SE(js_cc_extension_DownloadUnit_customId_set)); + cls->defineProperty("size", _SE(js_cc_extension_DownloadUnit_size_get), _SE(js_cc_extension_DownloadUnit_size_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_DownloadUnit)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_DownloadUnit_proto = cls->getProto(); + __jsb_cc_extension_DownloadUnit_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_ManifestAsset_class = nullptr; +se::Object* __jsb_cc_extension_ManifestAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_ManifestAsset) + +static bool js_cc_extension_ManifestAsset_md5_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->md5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_md5_set) + +static bool js_cc_extension_ManifestAsset_md5_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->md5, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->md5, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_md5_get) + +static bool js_cc_extension_ManifestAsset_path_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->path, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_path_set) + +static bool js_cc_extension_ManifestAsset_path_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->path, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->path, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_path_get) + +static bool js_cc_extension_ManifestAsset_compressed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compressed); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_compressed_set) + +static bool js_cc_extension_ManifestAsset_compressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compressed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_compressed_get) + +static bool js_cc_extension_ManifestAsset_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_size_set) + +static bool js_cc_extension_ManifestAsset_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_size_get) + +static bool js_cc_extension_ManifestAsset_downloadState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->downloadState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_downloadState_set) + +static bool js_cc_extension_ManifestAsset_downloadState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->downloadState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_downloadState_get) + +static bool js_new_cc_extension_ManifestAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::extension::ManifestAsset *result; + result = (cc::extension::ManifestAsset *)new cc::extension::ManifestAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_extension_ManifestAsset, __jsb_cc_extension_ManifestAsset_class, js_delete_cc_extension_ManifestAsset) + +static bool js_delete_cc_extension_ManifestAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_ManifestAsset) + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::ManifestAsset * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("md5", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->md5), ctx); + } + + + json->getProperty("path", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->path), ctx); + } + + + json->getProperty("compressed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compressed), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("downloadState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->downloadState), ctx); + } + + + return ok; +} + + +bool js_register_cc_extension_ManifestAsset(se::Object* obj) { + auto* cls = se::Class::create("ManifestAsset", obj, nullptr, _SE(js_new_cc_extension_ManifestAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("md5", _SE(js_cc_extension_ManifestAsset_md5_get), _SE(js_cc_extension_ManifestAsset_md5_set)); + cls->defineProperty("path", _SE(js_cc_extension_ManifestAsset_path_get), _SE(js_cc_extension_ManifestAsset_path_set)); + cls->defineProperty("compressed", _SE(js_cc_extension_ManifestAsset_compressed_get), _SE(js_cc_extension_ManifestAsset_compressed_set)); + cls->defineProperty("size", _SE(js_cc_extension_ManifestAsset_size_get), _SE(js_cc_extension_ManifestAsset_size_set)); + cls->defineProperty("downloadState", _SE(js_cc_extension_ManifestAsset_downloadState_get), _SE(js_cc_extension_ManifestAsset_downloadState_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_ManifestAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_ManifestAsset_proto = cls->getProto(); + __jsb_cc_extension_ManifestAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_Manifest_class = nullptr; +se::Object* __jsb_cc_extension_Manifest_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_Manifest) + +se::Class* __jsb_cc_extension_Manifest_AssetDiff_class = nullptr; +se::Object* __jsb_cc_extension_Manifest_AssetDiff_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_Manifest_AssetDiff) + +static bool js_cc_extension_Manifest_AssetDiff_asset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->asset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_Manifest_AssetDiff_asset_set) + +static bool js_cc_extension_Manifest_AssetDiff_asset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->asset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->asset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_Manifest_AssetDiff_asset_get) + +static bool js_cc_extension_Manifest_AssetDiff_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_Manifest_AssetDiff_type_set) + +static bool js_cc_extension_Manifest_AssetDiff_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_Manifest_AssetDiff_type_get) + +static bool js_new_cc_extension_Manifest_AssetDiff(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::extension::Manifest::AssetDiff *result; + result = (cc::extension::Manifest::AssetDiff *)new cc::extension::Manifest::AssetDiff(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_extension_Manifest_AssetDiff, __jsb_cc_extension_Manifest_AssetDiff_class, js_delete_cc_extension_Manifest_AssetDiff) + +static bool js_delete_cc_extension_Manifest_AssetDiff(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_Manifest_AssetDiff) + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::Manifest::AssetDiff * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("asset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->asset), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + return ok; +} + + +bool js_register_cc_extension_Manifest_AssetDiff(se::Object* obj) { + auto* cls = se::Class::create({"Manifest", "AssetDiff"}, obj, nullptr, _SE(js_new_cc_extension_Manifest_AssetDiff)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("asset", _SE(js_cc_extension_Manifest_AssetDiff_asset_get), _SE(js_cc_extension_Manifest_AssetDiff_asset_set)); + cls->defineProperty("type", _SE(js_cc_extension_Manifest_AssetDiff_type_get), _SE(js_cc_extension_Manifest_AssetDiff_type_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_Manifest_AssetDiff)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_Manifest_AssetDiff_proto = cls->getProto(); + __jsb_cc_extension_Manifest_AssetDiff_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_extension_Manifest_isVersionLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::Manifest const *)arg1)->isVersionLoaded(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_isVersionLoaded) + +static bool js_cc_extension_Manifest_isLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::Manifest const *)arg1)->isLoaded(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_isLoaded) + +static bool js_cc_extension_Manifest_getPackageUrl(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getPackageUrl(); + + 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_extension_Manifest_getPackageUrl) + +static bool js_cc_extension_Manifest_getManifestFileUrl(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getManifestFileUrl(); + + 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_extension_Manifest_getManifestFileUrl) + +static bool js_cc_extension_Manifest_getVersionFileUrl(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getVersionFileUrl(); + + 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_extension_Manifest_getVersionFileUrl) + +static bool js_cc_extension_Manifest_getVersion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getVersion(); + + 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_extension_Manifest_getVersion) + +static bool js_cc_extension_Manifest_getSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::vector< std::string > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::extension::Manifest const *)arg1)->getSearchPaths(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_getSearchPaths) + +static bool js_cc_extension_Manifest_getManifestRoot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getManifestRoot(); + + 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_extension_Manifest_getManifestRoot) + +static bool js_new_cc_extension_Manifest__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string temp1 ; + cc::extension::Manifest *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::extension::Manifest *)new cc::extension::Manifest((std::string const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_Manifest__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::extension::Manifest *result; + result = (cc::extension::Manifest *)new cc::extension::Manifest(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_Manifest__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::Manifest *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::extension::Manifest *)new cc::extension::Manifest((std::string const &)*arg1,(std::string const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_Manifest(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_cc_extension_Manifest__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_extension_Manifest__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_extension_Manifest__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Manifest"); + return false; +} +SE_BIND_CTOR(js_new_cc_extension_Manifest, __jsb_cc_extension_Manifest_class, js_delete_cc_extension_Manifest) + +static bool js_cc_extension_Manifest_parseFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->parseFile((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_parseFile) + +static bool js_cc_extension_Manifest_parseJSONString(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::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(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)->parseJSONString((std::string const &)*arg2,(std::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_parseJSONString) + +static bool js_cc_extension_Manifest_isUpdating(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::Manifest const *)arg1)->isUpdating(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_isUpdating) + +static bool js_cc_extension_Manifest_setUpdating(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUpdating(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_setUpdating) + +static bool js_delete_cc_extension_Manifest(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_Manifest) + +bool js_register_cc_extension_Manifest(se::Object* obj) { + auto* cls = se::Class::create("Manifest", obj, nullptr, _SE(js_new_cc_extension_Manifest)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("isVersionLoaded", _SE(js_cc_extension_Manifest_isVersionLoaded)); + cls->defineFunction("isLoaded", _SE(js_cc_extension_Manifest_isLoaded)); + cls->defineFunction("getPackageUrl", _SE(js_cc_extension_Manifest_getPackageUrl)); + cls->defineFunction("getManifestFileUrl", _SE(js_cc_extension_Manifest_getManifestFileUrl)); + cls->defineFunction("getVersionFileUrl", _SE(js_cc_extension_Manifest_getVersionFileUrl)); + cls->defineFunction("getVersion", _SE(js_cc_extension_Manifest_getVersion)); + cls->defineFunction("getSearchPaths", _SE(js_cc_extension_Manifest_getSearchPaths)); + cls->defineFunction("getManifestRoot", _SE(js_cc_extension_Manifest_getManifestRoot)); + cls->defineFunction("parseFile", _SE(js_cc_extension_Manifest_parseFile)); + cls->defineFunction("parseJSONString", _SE(js_cc_extension_Manifest_parseJSONString)); + cls->defineFunction("isUpdating", _SE(js_cc_extension_Manifest_isUpdating)); + cls->defineFunction("setUpdating", _SE(js_cc_extension_Manifest_setUpdating)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_Manifest)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_Manifest_proto = cls->getProto(); + __jsb_cc_extension_Manifest_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_AssetsManagerEx_class = nullptr; +se::Object* __jsb_cc_extension_AssetsManagerEx_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_AssetsManagerEx) + +static bool js_cc_extension_AssetsManager_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::AssetsManagerEx *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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::extension::AssetsManagerEx *)cc::extension::AssetsManagerEx::create((std::string const &)*arg1,(std::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_extension_AssetsManager_create_static) + +static bool js_new_cc_extension_AssetsManagerEx__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::AssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::extension::AssetsManagerEx *)new cc::extension::AssetsManagerEx((std::string const &)*arg1,(std::string const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_AssetsManagerEx__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + cc::extension::AssetsManagerEx::VersionCompareHandle arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::AssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::AssetsManagerEx *)new cc::extension::AssetsManagerEx((std::string const &)*arg1,(std::string const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_AssetsManagerEx(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 2) { + ret = js_new_cc_extension_AssetsManagerEx__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_extension_AssetsManagerEx__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of AssetsManager"); + return false; +} +SE_BIND_CTOR(js_new_cc_extension_AssetsManagerEx, __jsb_cc_extension_AssetsManagerEx_class, js_delete_cc_extension_AssetsManagerEx) + +static bool js_delete_cc_extension_AssetsManagerEx(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_AssetsManagerEx) + +static bool js_cc_extension_AssetsManager_checkUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->checkUpdate(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_checkUpdate) + +static bool js_cc_extension_AssetsManager_prepareUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->prepareUpdate(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_prepareUpdate) + +static bool js_cc_extension_AssetsManager_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_update) + +static bool js_cc_extension_AssetsManager_downloadFailedAssets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->downloadFailedAssets(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_downloadFailedAssets) + +static bool js_cc_extension_AssetsManager_getState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::State result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::extension::AssetsManagerEx::State)((cc::extension::AssetsManagerEx const *)arg1)->getState(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getState) + +static bool js_cc_extension_AssetsManager_getStoragePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::AssetsManagerEx const *)arg1)->getStoragePath(); + + 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_extension_AssetsManager_getStoragePath) + +static bool js_cc_extension_AssetsManager_getLocalManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *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(s); + if (nullptr == arg1) return true; + result = (cc::extension::Manifest *)((cc::extension::AssetsManagerEx const *)arg1)->getLocalManifest(); + + 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_extension_AssetsManager_getLocalManifest) + +static bool js_cc_extension_AssetsManager_loadLocalManifest__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *arg2 = (cc::extension::Manifest *) NULL ; + std::string *arg3 = 0 ; + std::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->loadLocalManifest(arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_extension_AssetsManager_loadLocalManifest__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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)(arg1)->loadLocalManifest((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_extension_AssetsManager_loadLocalManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_extension_AssetsManager_loadLocalManifest__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_extension_AssetsManager_loadLocalManifest__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_loadLocalManifest) + +static bool js_cc_extension_AssetsManager_getRemoteManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *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(s); + if (nullptr == arg1) return true; + result = (cc::extension::Manifest *)((cc::extension::AssetsManagerEx const *)arg1)->getRemoteManifest(); + + 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_extension_AssetsManager_getRemoteManifest) + +static bool js_cc_extension_AssetsManager_loadRemoteManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *arg2 = (cc::extension::Manifest *) 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(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)->loadRemoteManifest(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_loadRemoteManifest) + +static bool js_cc_extension_AssetsManager_isResuming(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::AssetsManagerEx const *)arg1)->isResuming(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_isResuming) + +static bool js_cc_extension_AssetsManager_getTotalBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::AssetsManagerEx const *)arg1)->getTotalBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getTotalBytes) + +static bool js_cc_extension_AssetsManager_getDownloadedBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::AssetsManagerEx const *)arg1)->getDownloadedBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getDownloadedBytes) + +static bool js_cc_extension_AssetsManager_getTotalFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getTotalFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getTotalFiles) + +static bool js_cc_extension_AssetsManager_getDownloadedFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getDownloadedFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getDownloadedFiles) + +static bool js_cc_extension_AssetsManager_getMaxConcurrentTask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getMaxConcurrentTask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getMaxConcurrentTask) + +static bool js_cc_extension_AssetsManager_setMaxConcurrentTask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaxConcurrentTask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setMaxConcurrentTask) + +static bool js_cc_extension_AssetsManager_setVersionCompareHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::VersionCompareHandle *arg2 = 0 ; + cc::extension::AssetsManagerEx::VersionCompareHandle temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setVersionCompareHandle((cc::extension::AssetsManagerEx::VersionCompareHandle const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setVersionCompareHandle) + +static bool js_cc_extension_AssetsManager_setVerifyCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::VerifyCallback *arg2 = 0 ; + cc::extension::AssetsManagerEx::VerifyCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setVerifyCallback((cc::extension::AssetsManagerEx::VerifyCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setVerifyCallback) + +static bool js_cc_extension_AssetsManager_setEventCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::EventCallback *arg2 = 0 ; + cc::extension::AssetsManagerEx::EventCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEventCallback((cc::extension::AssetsManagerEx::EventCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setEventCallback) + +static bool js_cc_extension_AssetsManager_cancelUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->cancelUpdate(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_cancelUpdate) + +bool js_register_cc_extension_AssetsManagerEx(se::Object* obj) { + auto* cls = se::Class::create("AssetsManager", obj, nullptr, _SE(js_new_cc_extension_AssetsManagerEx)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("checkUpdate", _SE(js_cc_extension_AssetsManager_checkUpdate)); + cls->defineFunction("prepareUpdate", _SE(js_cc_extension_AssetsManager_prepareUpdate)); + cls->defineFunction("update", _SE(js_cc_extension_AssetsManager_update)); + cls->defineFunction("downloadFailedAssets", _SE(js_cc_extension_AssetsManager_downloadFailedAssets)); + cls->defineFunction("getState", _SE(js_cc_extension_AssetsManager_getState)); + cls->defineFunction("getStoragePath", _SE(js_cc_extension_AssetsManager_getStoragePath)); + cls->defineFunction("getLocalManifest", _SE(js_cc_extension_AssetsManager_getLocalManifest)); + cls->defineFunction("loadLocalManifest", _SE(js_cc_extension_AssetsManager_loadLocalManifest)); + cls->defineFunction("getRemoteManifest", _SE(js_cc_extension_AssetsManager_getRemoteManifest)); + cls->defineFunction("loadRemoteManifest", _SE(js_cc_extension_AssetsManager_loadRemoteManifest)); + cls->defineFunction("isResuming", _SE(js_cc_extension_AssetsManager_isResuming)); + cls->defineFunction("getTotalBytes", _SE(js_cc_extension_AssetsManager_getTotalBytes)); + cls->defineFunction("getDownloadedBytes", _SE(js_cc_extension_AssetsManager_getDownloadedBytes)); + cls->defineFunction("getTotalFiles", _SE(js_cc_extension_AssetsManager_getTotalFiles)); + cls->defineFunction("getDownloadedFiles", _SE(js_cc_extension_AssetsManager_getDownloadedFiles)); + cls->defineFunction("getMaxConcurrentTask", _SE(js_cc_extension_AssetsManager_getMaxConcurrentTask)); + cls->defineFunction("setMaxConcurrentTask", _SE(js_cc_extension_AssetsManager_setMaxConcurrentTask)); + cls->defineFunction("setVersionCompareHandle", _SE(js_cc_extension_AssetsManager_setVersionCompareHandle)); + cls->defineFunction("setVerifyCallback", _SE(js_cc_extension_AssetsManager_setVerifyCallback)); + cls->defineFunction("setEventCallback", _SE(js_cc_extension_AssetsManager_setEventCallback)); + cls->defineFunction("cancelUpdate", _SE(js_cc_extension_AssetsManager_cancelUpdate)); + + + cls->defineStaticFunction("create", _SE(js_cc_extension_AssetsManager_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_AssetsManagerEx)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_AssetsManagerEx_proto = cls->getProto(); + __jsb_cc_extension_AssetsManagerEx_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_extension(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_extension_EventAssetsManagerEx(ns); + js_register_cc_extension_DownloadUnit(ns); + js_register_cc_extension_ManifestAsset(ns); + js_register_cc_extension_Manifest(ns); + js_register_cc_extension_Manifest_AssetDiff(ns); + js_register_cc_extension_AssetsManagerEx(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_extension_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_extension_auto.h new file mode 100644 index 0000000000..b348bffa0a --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_extension_auto.h @@ -0,0 +1,86 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "extensions/cocos-ext.h" + + + +bool register_all_extension(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::EventAssetsManagerEx); +extern se::Object *__jsb_cc_extension_EventAssetsManagerEx_proto; // NOLINT +extern se::Class * __jsb_cc_extension_EventAssetsManagerEx_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::DownloadUnit); +extern se::Object *__jsb_cc_extension_DownloadUnit_proto; // NOLINT +extern se::Class * __jsb_cc_extension_DownloadUnit_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::DownloadUnit * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::ManifestAsset); +extern se::Object *__jsb_cc_extension_ManifestAsset_proto; // NOLINT +extern se::Class * __jsb_cc_extension_ManifestAsset_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::ManifestAsset * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::Manifest::AssetDiff); +extern se::Object *__jsb_cc_extension_Manifest_AssetDiff_proto; // NOLINT +extern se::Class * __jsb_cc_extension_Manifest_AssetDiff_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::Manifest::AssetDiff * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::Manifest); +extern se::Object *__jsb_cc_extension_Manifest_proto; // NOLINT +extern se::Class * __jsb_cc_extension_Manifest_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::AssetsManagerEx); +extern se::Object *__jsb_cc_extension_AssetsManagerEx_proto; // NOLINT +extern se::Class * __jsb_cc_extension_AssetsManagerEx_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_geometry_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_geometry_auto.cpp new file mode 100644 index 0000000000..e0515cead1 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_geometry_auto.cpp @@ -0,0 +1,3965 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_geometry_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" + + +#define cc_geometry_ShapeBase__type_get(self_) self_->getType() +#define cc_geometry_ShapeBase__type_set(self_, val_) self_->setType(val_) + + + +se::Class* __jsb_cc_geometry_ShapeBase_class = nullptr; +se::Object* __jsb_cc_geometry_ShapeBase_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_ShapeBase) + +static bool js_new_cc_geometry_ShapeBase(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::geometry::ShapeEnum arg1 ; + cc::geometry::ShapeBase *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::ShapeBase *)new cc::geometry::ShapeBase(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_geometry_ShapeBase, __jsb_cc_geometry_ShapeBase_class, js_delete_cc_geometry_ShapeBase) + +static bool js_cc_geometry_ShapeBase__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::ShapeBase *arg1 = (cc::geometry::ShapeBase *) NULL ; + cc::geometry::ShapeEnum arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_geometry_ShapeBase__type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_ShapeBase__type_set) + +static bool js_cc_geometry_ShapeBase__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::ShapeBase *arg1 = (cc::geometry::ShapeBase *) NULL ; + cc::geometry::ShapeEnum result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::ShapeEnum)cc_geometry_ShapeBase__type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_ShapeBase__type_get) + +static bool js_delete_cc_geometry_ShapeBase(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_ShapeBase) + +bool js_register_cc_geometry_ShapeBase(se::Object* obj) { + auto* cls = se::Class::create("ShapeBase", obj, nullptr, _SE(js_new_cc_geometry_ShapeBase)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_type", _SE(js_cc_geometry_ShapeBase__type_get), _SE(js_cc_geometry_ShapeBase__type_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_ShapeBase)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_ShapeBase_proto = cls->getProto(); + __jsb_cc_geometry_ShapeBase_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_AABB_class = nullptr; +se::Object* __jsb_cc_geometry_AABB_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_AABB) + +static bool js_new_cc_geometry_AABB__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::AABB *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::AABB *)new cc::geometry::AABB(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_AABB__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::AABB *result; + result = (cc::geometry::AABB *)new cc::geometry::AABB(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_AABB(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 6) { + ret = js_new_cc_geometry_AABB__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_AABB__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of AABB"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_AABB, __jsb_cc_geometry_AABB_class, js_delete_cc_geometry_AABB) + +static bool js_delete_cc_geometry_AABB(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_AABB) + +static bool js_cc_geometry_AABB_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_AABB_center_set) + +static bool js_cc_geometry_AABB_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_AABB_center_get) + +static bool js_cc_geometry_AABB_halfExtents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->halfExtents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_AABB_halfExtents_set) + +static bool js_cc_geometry_AABB_halfExtents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->halfExtents, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->halfExtents, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_AABB_halfExtents_get) + +bool js_register_cc_geometry_AABB(se::Object* obj) { + auto* cls = se::Class::create("AABB", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_AABB)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("center", _SE(js_cc_geometry_AABB_center_get), _SE(js_cc_geometry_AABB_center_set)); + cls->defineProperty("halfExtents", _SE(js_cc_geometry_AABB_halfExtents_get), _SE(js_cc_geometry_AABB_halfExtents_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_AABB)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_AABB_proto = cls->getProto(); + __jsb_cc_geometry_AABB_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Line_class = nullptr; +se::Object* __jsb_cc_geometry_Line_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Line) + +static bool js_cc_geometry_Line_s_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->s, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Line_s_set) + +static bool js_cc_geometry_Line_s_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->s, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->s, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Line_s_get) + +static bool js_cc_geometry_Line_e_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->e, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Line_e_set) + +static bool js_cc_geometry_Line_e_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->e, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->e, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Line_e_get) + +static bool js_new_cc_geometry_Line__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Line *result; + result = (cc::geometry::Line *)new cc::geometry::Line(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = 0 ; + cc::geometry::Line temp1 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Line *)new cc::geometry::Line((cc::geometry::Line const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = 0 ; + cc::geometry::Line temp1 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Line *)new cc::geometry::Line((cc::geometry::Line &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 6) { + ret = js_new_cc_geometry_Line__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_geometry_Line__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_geometry_Line__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Line__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Line__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Line__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Line__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Line__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Line__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Line"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Line, __jsb_cc_geometry_Line_class, js_delete_cc_geometry_Line) + +static bool js_delete_cc_geometry_Line(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Line) + +bool js_register_cc_geometry_Line(se::Object* obj) { + auto* cls = se::Class::create("Line", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Line)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("s", _SE(js_cc_geometry_Line_s_get), _SE(js_cc_geometry_Line_s_set)); + cls->defineProperty("e", _SE(js_cc_geometry_Line_e_get), _SE(js_cc_geometry_Line_e_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Line)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Line_proto = cls->getProto(); + __jsb_cc_geometry_Line_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Plane_class = nullptr; +se::Object* __jsb_cc_geometry_Plane_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Plane) + +static bool js_new_cc_geometry_Plane__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Plane *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Plane *)new cc::geometry::Plane(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Plane__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Plane *result; + result = (cc::geometry::Plane *)new cc::geometry::Plane(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Plane(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 4) { + ret = js_new_cc_geometry_Plane__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Plane__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Plane"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Plane, __jsb_cc_geometry_Plane_class, js_delete_cc_geometry_Plane) + +static bool js_cc_geometry_Plane_n_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->n, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Plane_n_set) + +static bool js_cc_geometry_Plane_n_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->n, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->n, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Plane_n_get) + +static bool js_cc_geometry_Plane_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->d, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Plane_d_set) + +static bool js_cc_geometry_Plane_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->d, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Plane_d_get) + +static bool js_delete_cc_geometry_Plane(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Plane) + +bool js_register_cc_geometry_Plane(se::Object* obj) { + auto* cls = se::Class::create("Plane", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Plane)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("n", _SE(js_cc_geometry_Plane_n_get), _SE(js_cc_geometry_Plane_n_set)); + cls->defineProperty("d", _SE(js_cc_geometry_Plane_d_get), _SE(js_cc_geometry_Plane_d_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Plane)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Plane_proto = cls->getProto(); + __jsb_cc_geometry_Plane_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Frustum_class = nullptr; +se::Object* __jsb_cc_geometry_Frustum_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Frustum) + +static bool js_cc_geometry_Frustum_createOrthographic_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + cc::geometry::Frustum::createOrthographic(arg1,arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} + +static bool js_cc_geometry_Frustum_createPerspective_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + cc::geometry::Frustum::createPerspective(arg1,arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Frustum_createPerspective_static) + +static bool js_new_cc_geometry_Frustum__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Frustum *result; + result = (cc::geometry::Frustum *)new cc::geometry::Frustum(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Frustum__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Frustum *arg1 = 0 ; + cc::geometry::Frustum temp1 ; + cc::geometry::Frustum *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Frustum *)new cc::geometry::Frustum((cc::geometry::Frustum const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Frustum(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_geometry_Frustum__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Frustum__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Frustum"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Frustum, __jsb_cc_geometry_Frustum_class, js_delete_cc_geometry_Frustum) + +static bool js_delete_cc_geometry_Frustum(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Frustum) + +static bool js_cc_geometry_Frustum_createOrthographic__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->createOrthographic(arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} + +static bool js_cc_geometry_Frustum_createOrthographic(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_geometry_Frustum_createOrthographic_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_geometry_Frustum_createOrthographic__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Frustum_createOrthographic) + +static bool js_cc_geometry_Frustum_vertices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Frustum_vertices_set) + +static bool js_cc_geometry_Frustum_vertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Frustum_vertices_get) + +static bool js_cc_geometry_Frustum_planes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->planes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Frustum_planes_set) + +static bool js_cc_geometry_Frustum_planes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->planes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->planes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Frustum_planes_get) + +bool js_register_cc_geometry_Frustum(se::Object* obj) { + auto* cls = se::Class::create("Frustum", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Frustum)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertices", _SE(js_cc_geometry_Frustum_vertices_get), _SE(js_cc_geometry_Frustum_vertices_set)); + cls->defineProperty("planes", _SE(js_cc_geometry_Frustum_planes_get), _SE(js_cc_geometry_Frustum_planes_set)); + + cls->defineFunction("createOrthographic", _SE(js_cc_geometry_Frustum_createOrthographic)); + + + cls->defineStaticFunction("createPerspective", _SE(js_cc_geometry_Frustum_createPerspective_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Frustum)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Frustum_proto = cls->getProto(); + __jsb_cc_geometry_Frustum_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Capsule_class = nullptr; +se::Object* __jsb_cc_geometry_Capsule_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Capsule) + +static bool js_cc_geometry_Capsule_radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->radius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_radius_set) + +static bool js_cc_geometry_Capsule_radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->radius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_radius_get) + +static bool js_cc_geometry_Capsule_halfHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->halfHeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_halfHeight_set) + +static bool js_cc_geometry_Capsule_halfHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->halfHeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_halfHeight_get) + +static bool js_cc_geometry_Capsule_axis_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->axis, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_axis_set) + +static bool js_cc_geometry_Capsule_axis_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->axis, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->axis, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_axis_get) + +static bool js_cc_geometry_Capsule_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_center_set) + +static bool js_cc_geometry_Capsule_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_center_get) + +static bool js_cc_geometry_Capsule_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rotation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_rotation_set) + +static bool js_cc_geometry_Capsule_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rotation, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rotation, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_rotation_get) + +static bool js_cc_geometry_Capsule_ellipseCenter0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ellipseCenter0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_ellipseCenter0_set) + +static bool js_cc_geometry_Capsule_ellipseCenter0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ellipseCenter0, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ellipseCenter0, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_ellipseCenter0_get) + +static bool js_cc_geometry_Capsule_ellipseCenter1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ellipseCenter1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_ellipseCenter1_set) + +static bool js_cc_geometry_Capsule_ellipseCenter1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ellipseCenter1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ellipseCenter1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_ellipseCenter1_get) + +static bool js_new_cc_geometry_Capsule__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Capsule::CenterEnum arg3 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Capsule *result; + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = 0 ; + cc::geometry::Capsule temp1 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Capsule *)new cc::geometry::Capsule((cc::geometry::Capsule const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = 0 ; + cc::geometry::Capsule temp1 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Capsule *)new cc::geometry::Capsule((cc::geometry::Capsule &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_cc_geometry_Capsule__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Capsule__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Capsule__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Capsule__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Capsule__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Capsule__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Capsule"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Capsule, __jsb_cc_geometry_Capsule_class, js_delete_cc_geometry_Capsule) + +static bool js_delete_cc_geometry_Capsule(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Capsule) + +bool js_register_cc_geometry_Capsule(se::Object* obj) { + auto* cls = se::Class::create("Capsule", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Capsule)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("radius", _SE(js_cc_geometry_Capsule_radius_get), _SE(js_cc_geometry_Capsule_radius_set)); + cls->defineProperty("halfHeight", _SE(js_cc_geometry_Capsule_halfHeight_get), _SE(js_cc_geometry_Capsule_halfHeight_set)); + cls->defineProperty("axis", _SE(js_cc_geometry_Capsule_axis_get), _SE(js_cc_geometry_Capsule_axis_set)); + cls->defineProperty("center", _SE(js_cc_geometry_Capsule_center_get), _SE(js_cc_geometry_Capsule_center_set)); + cls->defineProperty("rotation", _SE(js_cc_geometry_Capsule_rotation_get), _SE(js_cc_geometry_Capsule_rotation_set)); + cls->defineProperty("ellipseCenter0", _SE(js_cc_geometry_Capsule_ellipseCenter0_get), _SE(js_cc_geometry_Capsule_ellipseCenter0_set)); + cls->defineProperty("ellipseCenter1", _SE(js_cc_geometry_Capsule_ellipseCenter1_get), _SE(js_cc_geometry_Capsule_ellipseCenter1_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Capsule)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Capsule_proto = cls->getProto(); + __jsb_cc_geometry_Capsule_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Sphere_class = nullptr; +se::Object* __jsb_cc_geometry_Sphere_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Sphere) + +static bool js_new_cc_geometry_Sphere__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Sphere *result; + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Sphere *arg1 = 0 ; + cc::geometry::Sphere temp1 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Sphere *)new cc::geometry::Sphere((cc::geometry::Sphere const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 4) { + ret = js_new_cc_geometry_Sphere__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Sphere__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Sphere__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Sphere__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Sphere__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Sphere__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Sphere"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Sphere, __jsb_cc_geometry_Sphere_class, js_delete_cc_geometry_Sphere) + +static bool js_delete_cc_geometry_Sphere(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Sphere) + +static bool js_cc_geometry_Sphere_intersect__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::geometry::Frustum temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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::geometry::Sphere const *)arg1)->intersect((cc::geometry::Frustum const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_geometry_Sphere_intersect__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + cc::geometry::Plane *arg2 = 0 ; + cc::geometry::Plane temp2 ; + int result; + + arg1 = SE_THIS_OBJECT(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 = (int)((cc::geometry::Sphere const *)arg1)->intersect((cc::geometry::Plane const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_geometry_Sphere_intersect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_geometry_Sphere_intersect__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Sphere_intersect__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Sphere_intersect) + +static bool js_cc_geometry_Sphere__radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_radius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Sphere__radius_set) + +static bool js_cc_geometry_Sphere__radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_radius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Sphere__radius_get) + +static bool js_cc_geometry_Sphere__center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Sphere__center_set) + +static bool js_cc_geometry_Sphere__center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Sphere__center_get) + +bool js_register_cc_geometry_Sphere(se::Object* obj) { + auto* cls = se::Class::create("Sphere", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Sphere)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_radius", _SE(js_cc_geometry_Sphere__radius_get), _SE(js_cc_geometry_Sphere__radius_set)); + cls->defineProperty("_center", _SE(js_cc_geometry_Sphere__center_get), _SE(js_cc_geometry_Sphere__center_set)); + + cls->defineFunction("intersect", _SE(js_cc_geometry_Sphere_intersect)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Sphere)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Sphere_proto = cls->getProto(); + __jsb_cc_geometry_Sphere_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Triangle_class = nullptr; +se::Object* __jsb_cc_geometry_Triangle_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Triangle) + +static bool js_cc_geometry_Triangle_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Triangle_a_set) + +static bool js_cc_geometry_Triangle_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->a, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Triangle_a_get) + +static bool js_cc_geometry_Triangle_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Triangle_b_set) + +static bool js_cc_geometry_Triangle_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->b, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Triangle_b_get) + +static bool js_cc_geometry_Triangle_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Triangle_c_set) + +static bool js_cc_geometry_Triangle_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Triangle_c_get) + +static bool js_new_cc_geometry_Triangle__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_9(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Triangle *result; + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_10(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = 0 ; + cc::geometry::Triangle temp1 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Triangle *)new cc::geometry::Triangle((cc::geometry::Triangle const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_11(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = 0 ; + cc::geometry::Triangle temp1 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Triangle *)new cc::geometry::Triangle((cc::geometry::Triangle &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 9) { + ret = js_new_cc_geometry_Triangle__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 8) { + ret = js_new_cc_geometry_Triangle__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 7) { + ret = js_new_cc_geometry_Triangle__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 6) { + ret = js_new_cc_geometry_Triangle__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_geometry_Triangle__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_geometry_Triangle__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Triangle__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Triangle__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Triangle__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Triangle__SWIG_9(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Triangle__SWIG_10(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Triangle__SWIG_11(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Triangle"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Triangle, __jsb_cc_geometry_Triangle_class, js_delete_cc_geometry_Triangle) + +static bool js_delete_cc_geometry_Triangle(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Triangle) + +bool js_register_cc_geometry_Triangle(se::Object* obj) { + auto* cls = se::Class::create("Triangle", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Triangle)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("a", _SE(js_cc_geometry_Triangle_a_get), _SE(js_cc_geometry_Triangle_a_set)); + cls->defineProperty("b", _SE(js_cc_geometry_Triangle_b_get), _SE(js_cc_geometry_Triangle_b_set)); + cls->defineProperty("c", _SE(js_cc_geometry_Triangle_c_get), _SE(js_cc_geometry_Triangle_c_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Triangle)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Triangle_proto = cls->getProto(); + __jsb_cc_geometry_Triangle_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Ray_class = nullptr; +se::Object* __jsb_cc_geometry_Ray_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Ray) + +static bool js_cc_geometry_Ray_o_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->o, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Ray_o_set) + +static bool js_cc_geometry_Ray_o_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->o, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->o, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Ray_o_get) + +static bool js_cc_geometry_Ray_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->d, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Ray_d_set) + +static bool js_cc_geometry_Ray_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->d, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->d, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Ray_d_get) + +static bool js_new_cc_geometry_Ray__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Ray *result; + result = (cc::geometry::Ray *)new cc::geometry::Ray(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = 0 ; + cc::geometry::Ray temp1 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Ray *)new cc::geometry::Ray((cc::geometry::Ray const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = 0 ; + cc::geometry::Ray temp1 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Ray *)new cc::geometry::Ray((cc::geometry::Ray &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 6) { + ret = js_new_cc_geometry_Ray__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_geometry_Ray__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_geometry_Ray__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Ray__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Ray__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Ray__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Ray__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Ray__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Ray__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Ray"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Ray, __jsb_cc_geometry_Ray_class, js_delete_cc_geometry_Ray) + +static bool js_delete_cc_geometry_Ray(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Ray) + +bool js_register_cc_geometry_Ray(se::Object* obj) { + auto* cls = se::Class::create("Ray", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Ray)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("o", _SE(js_cc_geometry_Ray_o_get), _SE(js_cc_geometry_Ray_o_set)); + cls->defineProperty("d", _SE(js_cc_geometry_Ray_d_get), _SE(js_cc_geometry_Ray_d_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Ray)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Ray_proto = cls->getProto(); + __jsb_cc_geometry_Ray_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Spline_class = nullptr; +se::Object* __jsb_cc_geometry_Spline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Spline) + +static bool js_new_cc_geometry_Spline__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::SplineMode arg1 ; + ccstd::vector< cc::Vec3 > arg2 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Spline *)new cc::geometry::Spline(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::SplineMode arg1 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Spline *)new cc::geometry::Spline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Spline *result; + result = (cc::geometry::Spline *)new cc::geometry::Spline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Spline *arg1 = 0 ; + cc::geometry::Spline temp1 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Spline *)new cc::geometry::Spline((cc::geometry::Spline const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Spline *arg1 = 0 ; + cc::geometry::Spline temp1 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Spline *)new cc::geometry::Spline((cc::geometry::Spline &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 2) { + ret = js_new_cc_geometry_Spline__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Spline__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Spline__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Spline__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Spline__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Spline"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Spline, __jsb_cc_geometry_Spline_class, js_delete_cc_geometry_Spline) + +static bool js_delete_cc_geometry_Spline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Spline) + +static bool js_cc_geometry_Spline_create_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::SplineMode arg1 ; + ccstd::vector< cc::Vec3 > *arg2 = 0 ; + ccstd::vector< cc::Vec3 > temp2 ; + cc::geometry::Spline *result = 0 ; + + + 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::geometry::Spline *)cc::geometry::Spline::create(arg1,(ccstd::vector< cc::Vec3 > 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; +} + +static bool js_cc_geometry_Spline_create_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::SplineMode arg1 ; + cc::geometry::Spline *result = 0 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Spline *)cc::geometry::Spline::create(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; +} + +static bool js_cc_geometry_Spline_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_geometry_Spline_create_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_create_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_create_static) + +static bool js_cc_geometry_Spline_clone_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = 0 ; + cc::geometry::Spline temp1 ; + cc::geometry::Spline *result = 0 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Spline *)cc::geometry::Spline::clone((cc::geometry::Spline const &)*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_FUNC(js_cc_geometry_Spline_clone_static) + +static bool js_cc_geometry_Spline_copy_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::geometry::Spline temp2 ; + cc::geometry::Spline *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::geometry::Spline *)cc::geometry::Spline::copy(arg1,(cc::geometry::Spline 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_geometry_Spline_copy_static) + +static bool js_cc_geometry_Spline_setMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::SplineMode arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setMode) + +static bool js_cc_geometry_Spline_getMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::SplineMode result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::SplineMode)((cc::geometry::Spline const *)arg1)->getMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getMode) + +static bool js_cc_geometry_Spline_setKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + ccstd::vector< cc::Vec3 > *arg2 = 0 ; + ccstd::vector< cc::Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setKnots((ccstd::vector< cc::Vec3 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setKnots) + +static bool js_cc_geometry_Spline_getKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + ccstd::vector< cc::Vec3 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Vec3 > *) &((cc::geometry::Spline const *)arg1)->getKnots(); + + 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_geometry_Spline_getKnots) + +static bool js_cc_geometry_Spline_clearKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearKnots(); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_clearKnots) + +static bool js_cc_geometry_Spline_getKnotCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::geometry::Spline const *)arg1)->getKnotCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getKnotCount) + +static bool js_cc_geometry_Spline_addKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addKnot((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_addKnot) + +static bool js_cc_geometry_Spline_setModeAndKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::SplineMode arg2 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< cc::Vec3 > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setModeAndKnots(arg2,(ccstd::vector< cc::Vec3 > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setModeAndKnots) + +static bool js_cc_geometry_Spline_insertKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->insertKnot(arg2,(cc::Vec3 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_insertKnot) + +static bool js_cc_geometry_Spline_removeKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->removeKnot(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_removeKnot) + +static bool js_cc_geometry_Spline_setKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setKnot(arg2,(cc::Vec3 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setKnot) + +static bool js_cc_geometry_Spline_getKnot__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Vec3 *) &((cc::geometry::Spline const *)arg1)->getKnot(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_geometry_Spline_getKnot__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Vec3 *) &(arg1)->getKnot(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_geometry_Spline_getKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_geometry_Spline_getKnot__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_getKnot__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getKnot) + +static bool js_cc_geometry_Spline_getPoint__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + float arg2 ; + uint32_t arg3 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + arg1 = SE_THIS_OBJECT(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::geometry::Spline const *)arg1)->getPoint(arg2,arg3); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} + +static bool js_cc_geometry_Spline_getPoint__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + float arg2 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((cc::geometry::Spline const *)arg1)->getPoint(arg2); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} + +static bool js_cc_geometry_Spline_getPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_geometry_Spline_getPoint__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_getPoint__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getPoint) + +static bool js_cc_geometry_Spline_getPoints__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::vector< cc::Vec3 > result; + + arg1 = SE_THIS_OBJECT(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::geometry::Spline const *)arg1)->getPoints(arg2,arg3); + + 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; +} + +static bool js_cc_geometry_Spline_getPoints__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + ccstd::vector< cc::Vec3 > result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::geometry::Spline const *)arg1)->getPoints(arg2); + + 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; +} + +static bool js_cc_geometry_Spline_getPoints(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_geometry_Spline_getPoints__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_getPoints__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getPoints) + +bool js_register_cc_geometry_Spline(se::Object* obj) { + auto* cls = se::Class::create("Spline", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Spline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setMode", _SE(js_cc_geometry_Spline_setMode)); + cls->defineFunction("getMode", _SE(js_cc_geometry_Spline_getMode)); + cls->defineFunction("setKnots", _SE(js_cc_geometry_Spline_setKnots)); + cls->defineFunction("getKnots", _SE(js_cc_geometry_Spline_getKnots)); + cls->defineFunction("clearKnots", _SE(js_cc_geometry_Spline_clearKnots)); + cls->defineFunction("getKnotCount", _SE(js_cc_geometry_Spline_getKnotCount)); + cls->defineFunction("addKnot", _SE(js_cc_geometry_Spline_addKnot)); + cls->defineFunction("setModeAndKnots", _SE(js_cc_geometry_Spline_setModeAndKnots)); + cls->defineFunction("insertKnot", _SE(js_cc_geometry_Spline_insertKnot)); + cls->defineFunction("removeKnot", _SE(js_cc_geometry_Spline_removeKnot)); + cls->defineFunction("setKnot", _SE(js_cc_geometry_Spline_setKnot)); + cls->defineFunction("getKnot", _SE(js_cc_geometry_Spline_getKnot)); + cls->defineFunction("getPoint", _SE(js_cc_geometry_Spline_getPoint)); + cls->defineFunction("getPoints", _SE(js_cc_geometry_Spline_getPoints)); + + + cls->defineStaticFunction("create", _SE(js_cc_geometry_Spline_create_static)); + cls->defineStaticFunction("clone", _SE(js_cc_geometry_Spline_clone_static)); + cls->defineStaticFunction("copy", _SE(js_cc_geometry_Spline_copy_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Spline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Spline_proto = cls->getProto(); + __jsb_cc_geometry_Spline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_geometry(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("ns", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("ns", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_geometry_ShapeBase(ns); + js_register_cc_geometry_AABB(ns); + js_register_cc_geometry_Line(ns); + js_register_cc_geometry_Plane(ns); + js_register_cc_geometry_Frustum(ns); + js_register_cc_geometry_Capsule(ns); + js_register_cc_geometry_Sphere(ns); + js_register_cc_geometry_Triangle(ns); + js_register_cc_geometry_Ray(ns); + js_register_cc_geometry_Spline(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_geometry_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_geometry_auto.h new file mode 100644 index 0000000000..81ea1379b3 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_geometry_auto.h @@ -0,0 +1,94 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "core/geometry/Geometry.h" + + + +bool register_all_geometry(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::ShapeBase); +extern se::Object *__jsb_cc_geometry_ShapeBase_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_ShapeBase_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::AABB); +extern se::Object *__jsb_cc_geometry_AABB_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_AABB_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Line); +extern se::Object *__jsb_cc_geometry_Line_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Line_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Plane); +extern se::Object *__jsb_cc_geometry_Plane_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Plane_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Frustum); +extern se::Object *__jsb_cc_geometry_Frustum_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Frustum_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Capsule); +extern se::Object *__jsb_cc_geometry_Capsule_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Capsule_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Sphere); +extern se::Object *__jsb_cc_geometry_Sphere_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Sphere_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Triangle); +extern se::Object *__jsb_cc_geometry_Triangle_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Triangle_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Ray); +extern se::Object *__jsb_cc_geometry_Ray_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Ray_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Spline); +extern se::Object *__jsb_cc_geometry_Spline_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Spline_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_gfx_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_gfx_auto.cpp new file mode 100644 index 0000000000..720035e773 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_gfx_auto.cpp @@ -0,0 +1,29905 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_gfx_auto.h" + + +#define cc_gfx_Device_gfxAPI_get(self_) self_->getGfxAPI() + + +#define cc_gfx_Device_deviceName_get(self_) self_->getDeviceName() + + +#define cc_gfx_Device_memoryStatus_get(self_) self_->getMemoryStatus() + + +#define cc_gfx_Device_queue_get(self_) self_->getQueue() + + +#define cc_gfx_Device_commandBuffer_get(self_) self_->getCommandBuffer() + + +#define cc_gfx_Device_renderer_get(self_) self_->getRenderer() + + +#define cc_gfx_Device_vendor_get(self_) self_->getVendor() + + +#define cc_gfx_Device_numDrawCalls_get(self_) self_->getNumDrawCalls() + + +#define cc_gfx_Device_numInstances_get(self_) self_->getNumInstances() + + +#define cc_gfx_Device_numTris_get(self_) self_->getNumTris() + + +#define cc_gfx_Device_capabilities_get(self_) self_->getCapabilities() + + +#define cc_gfx_Shader_name_get(self_) self_->getName() + + +#define cc_gfx_Shader_stages_get(self_) self_->getStages() + + +#define cc_gfx_Shader_attributes_get(self_) self_->getAttributes() + + +#define cc_gfx_Shader_blocks_get(self_) self_->getBlocks() + + +#define cc_gfx_Shader_samplers_get(self_) self_->getSamplers() + + +#define cc_gfx_Texture_info_get(self_) self_->getInfo() + + +#define cc_gfx_Texture_viewInfo_get(self_) self_->getViewInfo() + + +#define cc_gfx_Texture_width_get(self_) self_->getWidth() + + +#define cc_gfx_Texture_height_get(self_) self_->getHeight() + + +#define cc_gfx_Texture_format_get(self_) self_->getFormat() + + +#define cc_gfx_Texture_size_get(self_) self_->getSize() + + +#define cc_gfx_Texture_hash_get(self_) self_->getHash() + + +#define cc_gfx_Queue_type_get(self_) self_->getType() + + +#define cc_gfx_RenderPass_hash_get(self_) self_->getHash() + + +#define cc_gfx_DescriptorSet_layout_get(self_) self_->getLayout() + + +#define cc_gfx_DescriptorSetLayout_bindings_get(self_) self_->getBindings() + + +#define cc_gfx_PipelineState_shader_get(self_) self_->getShader() + + +#define cc_gfx_PipelineState_primitive_get(self_) self_->getPrimitive() + + +#define cc_gfx_PipelineState_bindPoint_get(self_) self_->getBindPoint() + + +#define cc_gfx_PipelineState_inputState_get(self_) self_->getInputState() + + +#define cc_gfx_PipelineState_rasterizerState_get(self_) self_->getRasterizerState() + + +#define cc_gfx_PipelineState_depthStencilState_get(self_) self_->getDepthStencilState() + + +#define cc_gfx_PipelineState_blendState_get(self_) self_->getBlendState() + + +#define cc_gfx_PipelineState_renderPass_get(self_) self_->getRenderPass() + + +#define cc_gfx_InputAssembler_vertexBuffers_get(self_) self_->getVertexBuffers() + + +#define cc_gfx_InputAssembler_attributes_get(self_) self_->getAttributes() + + +#define cc_gfx_InputAssembler_indexBuffer_get(self_) self_->getIndexBuffer() + + +#define cc_gfx_InputAssembler_indirectBuffer_get(self_) self_->getIndirectBuffer() + + +#define cc_gfx_InputAssembler_attributesHash_get(self_) self_->getAttributesHash() + + +#define cc_gfx_InputAssembler_drawInfo_get(self_) self_->getDrawInfo() +#define cc_gfx_InputAssembler_drawInfo_set(self_, val_) self_->setDrawInfo(val_) + + +#define cc_gfx_InputAssembler_vertexCount_get(self_) self_->getVertexCount() +#define cc_gfx_InputAssembler_vertexCount_set(self_, val_) self_->setVertexCount(val_) + + +#define cc_gfx_InputAssembler_firstVertex_get(self_) self_->getFirstVertex() +#define cc_gfx_InputAssembler_firstVertex_set(self_, val_) self_->setFirstVertex(val_) + + +#define cc_gfx_InputAssembler_indexCount_get(self_) self_->getIndexCount() +#define cc_gfx_InputAssembler_indexCount_set(self_, val_) self_->setIndexCount(val_) + + +#define cc_gfx_InputAssembler_firstIndex_get(self_) self_->getFirstIndex() +#define cc_gfx_InputAssembler_firstIndex_set(self_, val_) self_->setFirstIndex(val_) + + +#define cc_gfx_InputAssembler_vertexOffset_get(self_) self_->getVertexOffset() +#define cc_gfx_InputAssembler_vertexOffset_set(self_, val_) self_->setVertexOffset(val_) + + +#define cc_gfx_InputAssembler_instanceCount_get(self_) self_->getInstanceCount() +#define cc_gfx_InputAssembler_instanceCount_set(self_, val_) self_->setInstanceCount(val_) + + +#define cc_gfx_InputAssembler_firstInstance_get(self_) self_->getFirstInstance() +#define cc_gfx_InputAssembler_firstInstance_set(self_, val_) self_->setFirstInstance(val_) + + +#define cc_gfx_CommandBuffer_type_get(self_) self_->getType() + + +#define cc_gfx_CommandBuffer_queue_get(self_) self_->getQueue() + + +#define cc_gfx_CommandBuffer_numDrawCalls_get(self_) self_->getNumDrawCalls() + + +#define cc_gfx_CommandBuffer_numInstances_get(self_) self_->getNumInstances() + + +#define cc_gfx_CommandBuffer_numTris_get(self_) self_->getNumTris() + + +#define cc_gfx_Framebuffer_renderPass_get(self_) self_->getRenderPass() + + +#define cc_gfx_Framebuffer_colorTextures_get(self_) self_->getColorTextures() + + +#define cc_gfx_Framebuffer_depthStencilTexture_get(self_) self_->getDepthStencilTexture() + + +#define cc_gfx_Buffer_usage_get(self_) self_->getUsage() + + +#define cc_gfx_Buffer_memUsage_get(self_) self_->getMemUsage() + + +#define cc_gfx_Buffer_stride_get(self_) self_->getStride() + + +#define cc_gfx_Buffer_count_get(self_) self_->getCount() + + +#define cc_gfx_Buffer_size_get(self_) self_->getSize() + + +#define cc_gfx_Buffer_flags_get(self_) self_->getFlags() + + +#define cc_gfx_Sampler_info_get(self_) self_->getInfo() + + +#define cc_gfx_Sampler_hash_get(self_) self_->getHash() + + +#define cc_gfx_Swapchain_width_get(self_) self_->getWidth() + + +#define cc_gfx_Swapchain_height_get(self_) self_->getHeight() + + +#define cc_gfx_Swapchain_surfaceTransform_get(self_) self_->getSurfaceTransform() + + +#define cc_gfx_Swapchain_colorTexture_get(self_) self_->getColorTexture() + + +#define cc_gfx_Swapchain_depthStencilTexture_get(self_) self_->getDepthStencilTexture() + + +#define cc_gfx_GFXObject_objectType_get(self_) self_->getObjectType() + + +#define cc_gfx_GFXObject_objectID_get(self_) self_->getObjectID() + + +#define cc_gfx_GFXObject_typedID_get(self_) self_->getTypedID() + + +#define cc_gfx_GeneralBarrier_hash_get(self_) self_->getHash() + + +#define cc_gfx_GeneralBarrier_info_get(self_) self_->getInfo() + + +#define cc_gfx_TextureBarrier_hash_get(self_) self_->getHash() + + +#define cc_gfx_TextureBarrier_info_get(self_) self_->getInfo() + + + +static bool js_cc_gfx_isCombinedImageSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Type arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::gfx::isCombinedImageSampler(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_isCombinedImageSampler) + +static bool js_cc_gfx_isSampledImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Type arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::gfx::isSampledImage(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_isSampledImage) + +static bool js_cc_gfx_isStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Type arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::gfx::isStorageImage(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_isStorageImage) + +se::Class* __jsb_cc_gfx_Size_class = nullptr; +se::Object* __jsb_cc_gfx_Size_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Size) + +static bool js_cc_gfx_Size_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Size_x_set) + +static bool js_cc_gfx_Size_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Size_x_get) + +static bool js_cc_gfx_Size_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Size_y_set) + +static bool js_cc_gfx_Size_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Size_y_get) + +static bool js_cc_gfx_Size_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Size_z_set) + +static bool js_cc_gfx_Size_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Size_z_get) + +static bool js_cc_gfx_Size_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + cc::gfx::Size *arg2 = 0 ; + cc::gfx::Size temp2 ; + cc::gfx::Size *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(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::gfx::Size *) &(arg1)->copy((cc::gfx::Size 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_gfx_Size_copy) + +static bool js_new_cc_gfx_Size(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Size *result; + result = (cc::gfx::Size *)new cc::gfx::Size(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Size, __jsb_cc_gfx_Size_class, js_delete_cc_gfx_Size) + +static bool js_delete_cc_gfx_Size(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Size) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Size * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Size(se::Object* obj) { + auto* cls = se::Class::create("Size", obj, nullptr, _SE(js_new_cc_gfx_Size)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Size_x_get), _SE(js_cc_gfx_Size_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Size_y_get), _SE(js_cc_gfx_Size_y_set)); + cls->defineProperty("z", _SE(js_cc_gfx_Size_z_get), _SE(js_cc_gfx_Size_z_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Size_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Size)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Size_proto = cls->getProto(); + __jsb_cc_gfx_Size_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceCaps_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceCaps_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceCaps) + +static bool js_cc_gfx_DeviceCaps_maxVertexAttributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxVertexAttributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxVertexAttributes_set) + +static bool js_cc_gfx_DeviceCaps_maxVertexAttributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxVertexAttributes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxVertexAttributes_get) + +static bool js_cc_gfx_DeviceCaps_maxVertexUniformVectors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxVertexUniformVectors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_set) + +static bool js_cc_gfx_DeviceCaps_maxVertexUniformVectors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxVertexUniformVectors, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_get) + +static bool js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxFragmentUniformVectors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_set) + +static bool js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxFragmentUniformVectors, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_get) + +static bool js_cc_gfx_DeviceCaps_maxTextureUnits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTextureUnits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxTextureUnits_set) + +static bool js_cc_gfx_DeviceCaps_maxTextureUnits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTextureUnits, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxTextureUnits_get) + +static bool js_cc_gfx_DeviceCaps_maxImageUnits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxImageUnits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxImageUnits_set) + +static bool js_cc_gfx_DeviceCaps_maxImageUnits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxImageUnits, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxImageUnits_get) + +static bool js_cc_gfx_DeviceCaps_maxVertexTextureUnits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxVertexTextureUnits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_set) + +static bool js_cc_gfx_DeviceCaps_maxVertexTextureUnits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxVertexTextureUnits, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_get) + +static bool js_cc_gfx_DeviceCaps_maxColorRenderTargets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxColorRenderTargets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxColorRenderTargets_set) + +static bool js_cc_gfx_DeviceCaps_maxColorRenderTargets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxColorRenderTargets, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxColorRenderTargets_get) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxShaderStorageBufferBindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_set) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxShaderStorageBufferBindings, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_get) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxShaderStorageBlockSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_set) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxShaderStorageBlockSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_get) + +static bool js_cc_gfx_DeviceCaps_maxUniformBufferBindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxUniformBufferBindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_set) + +static bool js_cc_gfx_DeviceCaps_maxUniformBufferBindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxUniformBufferBindings, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_get) + +static bool js_cc_gfx_DeviceCaps_maxUniformBlockSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxUniformBlockSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxUniformBlockSize_set) + +static bool js_cc_gfx_DeviceCaps_maxUniformBlockSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxUniformBlockSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxUniformBlockSize_get) + +static bool js_cc_gfx_DeviceCaps_maxTextureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTextureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxTextureSize_set) + +static bool js_cc_gfx_DeviceCaps_maxTextureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTextureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxTextureSize_get) + +static bool js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxCubeMapTextureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_set) + +static bool js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxCubeMapTextureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_get) + +static bool js_cc_gfx_DeviceCaps_maxArrayTextureLayers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxArrayTextureLayers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_set) + +static bool js_cc_gfx_DeviceCaps_maxArrayTextureLayers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxArrayTextureLayers, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_get) + +static bool js_cc_gfx_DeviceCaps_max3DTextureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->max3DTextureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_max3DTextureSize_set) + +static bool js_cc_gfx_DeviceCaps_max3DTextureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->max3DTextureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_max3DTextureSize_get) + +static bool js_cc_gfx_DeviceCaps_uboOffsetAlignment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uboOffsetAlignment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_uboOffsetAlignment_set) + +static bool js_cc_gfx_DeviceCaps_uboOffsetAlignment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uboOffsetAlignment, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_uboOffsetAlignment_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeSharedMemorySize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeSharedMemorySize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeWorkGroupInvocations, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeWorkGroupInvocations, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeWorkGroupSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeWorkGroupSize, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxComputeWorkGroupSize, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeWorkGroupCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeWorkGroupCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxComputeWorkGroupCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_get) + +static bool js_cc_gfx_DeviceCaps_supportQuery_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->supportQuery); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_supportQuery_set) + +static bool js_cc_gfx_DeviceCaps_supportQuery_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->supportQuery, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_supportQuery_get) + +static bool js_cc_gfx_DeviceCaps_supportVariableRateShading_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->supportVariableRateShading); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_supportVariableRateShading_set) + +static bool js_cc_gfx_DeviceCaps_supportVariableRateShading_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->supportVariableRateShading, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_supportVariableRateShading_get) + +static bool js_cc_gfx_DeviceCaps_supportSubPassShading_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->supportSubPassShading); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_supportSubPassShading_set) + +static bool js_cc_gfx_DeviceCaps_supportSubPassShading_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->supportSubPassShading, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_supportSubPassShading_get) + +static bool js_cc_gfx_DeviceCaps_clipSpaceMinZ_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->clipSpaceMinZ, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_clipSpaceMinZ_set) + +static bool js_cc_gfx_DeviceCaps_clipSpaceMinZ_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->clipSpaceMinZ, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_clipSpaceMinZ_get) + +static bool js_cc_gfx_DeviceCaps_screenSpaceSignY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->screenSpaceSignY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_screenSpaceSignY_set) + +static bool js_cc_gfx_DeviceCaps_screenSpaceSignY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->screenSpaceSignY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_screenSpaceSignY_get) + +static bool js_cc_gfx_DeviceCaps_clipSpaceSignY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->clipSpaceSignY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_clipSpaceSignY_set) + +static bool js_cc_gfx_DeviceCaps_clipSpaceSignY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->clipSpaceSignY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_clipSpaceSignY_get) + +static bool js_cc_gfx_DeviceCaps_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + cc::gfx::DeviceCaps *arg2 = 0 ; + cc::gfx::DeviceCaps temp2 ; + cc::gfx::DeviceCaps *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(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::gfx::DeviceCaps *) &(arg1)->copy((cc::gfx::DeviceCaps 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_gfx_DeviceCaps_copy) + +static bool js_new_cc_gfx_DeviceCaps(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceCaps *result; + result = (cc::gfx::DeviceCaps *)new cc::gfx::DeviceCaps(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceCaps, __jsb_cc_gfx_DeviceCaps_class, js_delete_cc_gfx_DeviceCaps) + +static bool js_delete_cc_gfx_DeviceCaps(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceCaps) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceCaps * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxVertexAttributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxVertexAttributes), ctx); + } + + + json->getProperty("maxVertexUniformVectors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxVertexUniformVectors), ctx); + } + + + json->getProperty("maxFragmentUniformVectors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxFragmentUniformVectors), ctx); + } + + + json->getProperty("maxTextureUnits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTextureUnits), ctx); + } + + + json->getProperty("maxImageUnits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxImageUnits), ctx); + } + + + json->getProperty("maxVertexTextureUnits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxVertexTextureUnits), ctx); + } + + + json->getProperty("maxColorRenderTargets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxColorRenderTargets), ctx); + } + + + json->getProperty("maxShaderStorageBufferBindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxShaderStorageBufferBindings), ctx); + } + + + json->getProperty("maxShaderStorageBlockSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxShaderStorageBlockSize), ctx); + } + + + json->getProperty("maxUniformBufferBindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxUniformBufferBindings), ctx); + } + + + json->getProperty("maxUniformBlockSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxUniformBlockSize), ctx); + } + + + json->getProperty("maxTextureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTextureSize), ctx); + } + + + json->getProperty("maxCubeMapTextureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxCubeMapTextureSize), ctx); + } + + + json->getProperty("maxArrayTextureLayers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxArrayTextureLayers), ctx); + } + + + json->getProperty("max3DTextureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->max3DTextureSize), ctx); + } + + + json->getProperty("uboOffsetAlignment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uboOffsetAlignment), ctx); + } + + + json->getProperty("maxComputeSharedMemorySize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeSharedMemorySize), ctx); + } + + + json->getProperty("maxComputeWorkGroupInvocations", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeWorkGroupInvocations), ctx); + } + + + json->getProperty("maxComputeWorkGroupSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeWorkGroupSize), ctx); + } + + + json->getProperty("maxComputeWorkGroupCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeWorkGroupCount), ctx); + } + + + json->getProperty("supportQuery", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->supportQuery), ctx); + } + + + json->getProperty("supportVariableRateShading", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->supportVariableRateShading), ctx); + } + + + json->getProperty("supportSubPassShading", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->supportSubPassShading), ctx); + } + + + json->getProperty("clipSpaceMinZ", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->clipSpaceMinZ), ctx); + } + + + json->getProperty("screenSpaceSignY", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->screenSpaceSignY), ctx); + } + + + json->getProperty("clipSpaceSignY", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->clipSpaceSignY), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DeviceCaps(se::Object* obj) { + auto* cls = se::Class::create("DeviceCaps", obj, nullptr, _SE(js_new_cc_gfx_DeviceCaps)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxVertexAttributes", _SE(js_cc_gfx_DeviceCaps_maxVertexAttributes_get), _SE(js_cc_gfx_DeviceCaps_maxVertexAttributes_set)); + cls->defineProperty("maxVertexUniformVectors", _SE(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_get), _SE(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_set)); + cls->defineProperty("maxFragmentUniformVectors", _SE(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_get), _SE(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_set)); + cls->defineProperty("maxTextureUnits", _SE(js_cc_gfx_DeviceCaps_maxTextureUnits_get), _SE(js_cc_gfx_DeviceCaps_maxTextureUnits_set)); + cls->defineProperty("maxImageUnits", _SE(js_cc_gfx_DeviceCaps_maxImageUnits_get), _SE(js_cc_gfx_DeviceCaps_maxImageUnits_set)); + cls->defineProperty("maxVertexTextureUnits", _SE(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_get), _SE(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_set)); + cls->defineProperty("maxColorRenderTargets", _SE(js_cc_gfx_DeviceCaps_maxColorRenderTargets_get), _SE(js_cc_gfx_DeviceCaps_maxColorRenderTargets_set)); + cls->defineProperty("maxShaderStorageBufferBindings", _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_get), _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_set)); + cls->defineProperty("maxShaderStorageBlockSize", _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_get), _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_set)); + cls->defineProperty("maxUniformBufferBindings", _SE(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_get), _SE(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_set)); + cls->defineProperty("maxUniformBlockSize", _SE(js_cc_gfx_DeviceCaps_maxUniformBlockSize_get), _SE(js_cc_gfx_DeviceCaps_maxUniformBlockSize_set)); + cls->defineProperty("maxTextureSize", _SE(js_cc_gfx_DeviceCaps_maxTextureSize_get), _SE(js_cc_gfx_DeviceCaps_maxTextureSize_set)); + cls->defineProperty("maxCubeMapTextureSize", _SE(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_get), _SE(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_set)); + cls->defineProperty("maxArrayTextureLayers", _SE(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_get), _SE(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_set)); + cls->defineProperty("max3DTextureSize", _SE(js_cc_gfx_DeviceCaps_max3DTextureSize_get), _SE(js_cc_gfx_DeviceCaps_max3DTextureSize_set)); + cls->defineProperty("uboOffsetAlignment", _SE(js_cc_gfx_DeviceCaps_uboOffsetAlignment_get), _SE(js_cc_gfx_DeviceCaps_uboOffsetAlignment_set)); + cls->defineProperty("maxComputeSharedMemorySize", _SE(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_get), _SE(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_set)); + cls->defineProperty("maxComputeWorkGroupInvocations", _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_get), _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_set)); + cls->defineProperty("maxComputeWorkGroupSize", _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_get), _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_set)); + cls->defineProperty("maxComputeWorkGroupCount", _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_get), _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_set)); + cls->defineProperty("supportQuery", _SE(js_cc_gfx_DeviceCaps_supportQuery_get), _SE(js_cc_gfx_DeviceCaps_supportQuery_set)); + cls->defineProperty("supportVariableRateShading", _SE(js_cc_gfx_DeviceCaps_supportVariableRateShading_get), _SE(js_cc_gfx_DeviceCaps_supportVariableRateShading_set)); + cls->defineProperty("supportSubPassShading", _SE(js_cc_gfx_DeviceCaps_supportSubPassShading_get), _SE(js_cc_gfx_DeviceCaps_supportSubPassShading_set)); + cls->defineProperty("clipSpaceMinZ", _SE(js_cc_gfx_DeviceCaps_clipSpaceMinZ_get), _SE(js_cc_gfx_DeviceCaps_clipSpaceMinZ_set)); + cls->defineProperty("screenSpaceSignY", _SE(js_cc_gfx_DeviceCaps_screenSpaceSignY_get), _SE(js_cc_gfx_DeviceCaps_screenSpaceSignY_set)); + cls->defineProperty("clipSpaceSignY", _SE(js_cc_gfx_DeviceCaps_clipSpaceSignY_get), _SE(js_cc_gfx_DeviceCaps_clipSpaceSignY_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DeviceCaps_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceCaps)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceCaps_proto = cls->getProto(); + __jsb_cc_gfx_DeviceCaps_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceOptions_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceOptions) + +static bool js_cc_gfx_DeviceOptions_enableBarrierDeduce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceOptions *arg1 = (cc::gfx::DeviceOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableBarrierDeduce); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceOptions_enableBarrierDeduce_set) + +static bool js_cc_gfx_DeviceOptions_enableBarrierDeduce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceOptions *arg1 = (cc::gfx::DeviceOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableBarrierDeduce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceOptions_enableBarrierDeduce_get) + +static bool js_new_cc_gfx_DeviceOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceOptions *result; + result = (cc::gfx::DeviceOptions *)new cc::gfx::DeviceOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceOptions, __jsb_cc_gfx_DeviceOptions_class, js_delete_cc_gfx_DeviceOptions) + +static bool js_delete_cc_gfx_DeviceOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("enableBarrierDeduce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableBarrierDeduce), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DeviceOptions(se::Object* obj) { + auto* cls = se::Class::create("DeviceOptions", obj, nullptr, _SE(js_new_cc_gfx_DeviceOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enableBarrierDeduce", _SE(js_cc_gfx_DeviceOptions_enableBarrierDeduce_get), _SE(js_cc_gfx_DeviceOptions_enableBarrierDeduce_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceOptions_proto = cls->getProto(); + __jsb_cc_gfx_DeviceOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Offset_class = nullptr; +se::Object* __jsb_cc_gfx_Offset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Offset) + +static bool js_cc_gfx_Offset_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Offset_x_set) + +static bool js_cc_gfx_Offset_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Offset_x_get) + +static bool js_cc_gfx_Offset_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Offset_y_set) + +static bool js_cc_gfx_Offset_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Offset_y_get) + +static bool js_cc_gfx_Offset_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Offset_z_set) + +static bool js_cc_gfx_Offset_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Offset_z_get) + +static bool js_cc_gfx_Offset_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + cc::gfx::Offset *arg2 = 0 ; + cc::gfx::Offset temp2 ; + cc::gfx::Offset *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(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::gfx::Offset *) &(arg1)->copy((cc::gfx::Offset 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_gfx_Offset_copy) + +static bool js_new_cc_gfx_Offset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Offset *result; + result = (cc::gfx::Offset *)new cc::gfx::Offset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Offset, __jsb_cc_gfx_Offset_class, js_delete_cc_gfx_Offset) + +static bool js_delete_cc_gfx_Offset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Offset) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Offset * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Offset(se::Object* obj) { + auto* cls = se::Class::create("Offset", obj, nullptr, _SE(js_new_cc_gfx_Offset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Offset_x_get), _SE(js_cc_gfx_Offset_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Offset_y_get), _SE(js_cc_gfx_Offset_y_set)); + cls->defineProperty("z", _SE(js_cc_gfx_Offset_z_get), _SE(js_cc_gfx_Offset_z_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Offset_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Offset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Offset_proto = cls->getProto(); + __jsb_cc_gfx_Offset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Rect_class = nullptr; +se::Object* __jsb_cc_gfx_Rect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Rect) + +static bool js_cc_gfx_Rect_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_x_set) + +static bool js_cc_gfx_Rect_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_x_get) + +static bool js_cc_gfx_Rect_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_y_set) + +static bool js_cc_gfx_Rect_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_y_get) + +static bool js_cc_gfx_Rect_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_width_set) + +static bool js_cc_gfx_Rect_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_width_get) + +static bool js_cc_gfx_Rect_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_height_set) + +static bool js_cc_gfx_Rect_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_height_get) + +static bool js_cc_gfx_Rect_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + cc::gfx::Rect *arg2 = 0 ; + cc::gfx::Rect temp2 ; + cc::gfx::Rect *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(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::gfx::Rect *) &(arg1)->copy((cc::gfx::Rect 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_gfx_Rect_copy) + +static bool js_new_cc_gfx_Rect(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Rect *result; + result = (cc::gfx::Rect *)new cc::gfx::Rect(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Rect, __jsb_cc_gfx_Rect_class, js_delete_cc_gfx_Rect) + +static bool js_delete_cc_gfx_Rect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Rect) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Rect * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Rect(se::Object* obj) { + auto* cls = se::Class::create("Rect", obj, nullptr, _SE(js_new_cc_gfx_Rect)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Rect_x_get), _SE(js_cc_gfx_Rect_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Rect_y_get), _SE(js_cc_gfx_Rect_y_set)); + cls->defineProperty("width", _SE(js_cc_gfx_Rect_width_get), _SE(js_cc_gfx_Rect_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_Rect_height_get), _SE(js_cc_gfx_Rect_height_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Rect_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Rect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Rect_proto = cls->getProto(); + __jsb_cc_gfx_Rect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Extent_class = nullptr; +se::Object* __jsb_cc_gfx_Extent_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Extent) + +static bool js_cc_gfx_Extent_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Extent_width_set) + +static bool js_cc_gfx_Extent_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Extent_width_get) + +static bool js_cc_gfx_Extent_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Extent_height_set) + +static bool js_cc_gfx_Extent_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Extent_height_get) + +static bool js_cc_gfx_Extent_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Extent_depth_set) + +static bool js_cc_gfx_Extent_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Extent_depth_get) + +static bool js_cc_gfx_Extent_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + cc::gfx::Extent *arg2 = 0 ; + cc::gfx::Extent temp2 ; + cc::gfx::Extent *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(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::gfx::Extent *) &(arg1)->copy((cc::gfx::Extent 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_gfx_Extent_copy) + +static bool js_new_cc_gfx_Extent(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Extent *result; + result = (cc::gfx::Extent *)new cc::gfx::Extent(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Extent, __jsb_cc_gfx_Extent_class, js_delete_cc_gfx_Extent) + +static bool js_delete_cc_gfx_Extent(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Extent) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Extent * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Extent(se::Object* obj) { + auto* cls = se::Class::create("Extent", obj, nullptr, _SE(js_new_cc_gfx_Extent)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_gfx_Extent_width_get), _SE(js_cc_gfx_Extent_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_Extent_height_get), _SE(js_cc_gfx_Extent_height_set)); + cls->defineProperty("depth", _SE(js_cc_gfx_Extent_depth_get), _SE(js_cc_gfx_Extent_depth_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Extent_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Extent)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Extent_proto = cls->getProto(); + __jsb_cc_gfx_Extent_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureSubresLayers_class = nullptr; +se::Object* __jsb_cc_gfx_TextureSubresLayers_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresLayers) + +static bool js_cc_gfx_TextureSubresLayers_mipLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresLayers_mipLevel_set) + +static bool js_cc_gfx_TextureSubresLayers_mipLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresLayers_mipLevel_get) + +static bool js_cc_gfx_TextureSubresLayers_baseArrayLayer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseArrayLayer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresLayers_baseArrayLayer_set) + +static bool js_cc_gfx_TextureSubresLayers_baseArrayLayer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseArrayLayer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresLayers_baseArrayLayer_get) + +static bool js_cc_gfx_TextureSubresLayers_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresLayers_layerCount_set) + +static bool js_cc_gfx_TextureSubresLayers_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresLayers_layerCount_get) + +static bool js_cc_gfx_TextureSubresLayers_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + cc::gfx::TextureSubresLayers *arg2 = 0 ; + cc::gfx::TextureSubresLayers temp2 ; + cc::gfx::TextureSubresLayers *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(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::gfx::TextureSubresLayers *) &(arg1)->copy((cc::gfx::TextureSubresLayers 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_gfx_TextureSubresLayers_copy) + +static bool js_new_cc_gfx_TextureSubresLayers(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureSubresLayers *result; + result = (cc::gfx::TextureSubresLayers *)new cc::gfx::TextureSubresLayers(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureSubresLayers, __jsb_cc_gfx_TextureSubresLayers_class, js_delete_cc_gfx_TextureSubresLayers) + +static bool js_delete_cc_gfx_TextureSubresLayers(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresLayers) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresLayers * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("mipLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipLevel), ctx); + } + + + json->getProperty("baseArrayLayer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseArrayLayer), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureSubresLayers(se::Object* obj) { + auto* cls = se::Class::create("TextureSubresLayers", obj, nullptr, _SE(js_new_cc_gfx_TextureSubresLayers)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mipLevel", _SE(js_cc_gfx_TextureSubresLayers_mipLevel_get), _SE(js_cc_gfx_TextureSubresLayers_mipLevel_set)); + cls->defineProperty("baseArrayLayer", _SE(js_cc_gfx_TextureSubresLayers_baseArrayLayer_get), _SE(js_cc_gfx_TextureSubresLayers_baseArrayLayer_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureSubresLayers_layerCount_get), _SE(js_cc_gfx_TextureSubresLayers_layerCount_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureSubresLayers_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureSubresLayers)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureSubresLayers_proto = cls->getProto(); + __jsb_cc_gfx_TextureSubresLayers_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureSubresRange_class = nullptr; +se::Object* __jsb_cc_gfx_TextureSubresRange_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresRange) + +static bool js_cc_gfx_TextureSubresRange_baseMipLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseMipLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_baseMipLevel_set) + +static bool js_cc_gfx_TextureSubresRange_baseMipLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseMipLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_baseMipLevel_get) + +static bool js_cc_gfx_TextureSubresRange_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_levelCount_set) + +static bool js_cc_gfx_TextureSubresRange_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_levelCount_get) + +static bool js_cc_gfx_TextureSubresRange_baseArrayLayer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseArrayLayer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_baseArrayLayer_set) + +static bool js_cc_gfx_TextureSubresRange_baseArrayLayer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseArrayLayer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_baseArrayLayer_get) + +static bool js_cc_gfx_TextureSubresRange_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_layerCount_set) + +static bool js_cc_gfx_TextureSubresRange_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_layerCount_get) + +static bool js_cc_gfx_TextureSubresRange_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + cc::gfx::TextureSubresRange *arg2 = 0 ; + cc::gfx::TextureSubresRange temp2 ; + cc::gfx::TextureSubresRange *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(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::gfx::TextureSubresRange *) &(arg1)->copy((cc::gfx::TextureSubresRange 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_gfx_TextureSubresRange_copy) + +static bool js_new_cc_gfx_TextureSubresRange(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureSubresRange *result; + result = (cc::gfx::TextureSubresRange *)new cc::gfx::TextureSubresRange(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureSubresRange, __jsb_cc_gfx_TextureSubresRange_class, js_delete_cc_gfx_TextureSubresRange) + +static bool js_delete_cc_gfx_TextureSubresRange(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresRange) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresRange * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("baseMipLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseMipLevel), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("baseArrayLayer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseArrayLayer), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureSubresRange(se::Object* obj) { + auto* cls = se::Class::create("TextureSubresRange", obj, nullptr, _SE(js_new_cc_gfx_TextureSubresRange)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("baseMipLevel", _SE(js_cc_gfx_TextureSubresRange_baseMipLevel_get), _SE(js_cc_gfx_TextureSubresRange_baseMipLevel_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_TextureSubresRange_levelCount_get), _SE(js_cc_gfx_TextureSubresRange_levelCount_set)); + cls->defineProperty("baseArrayLayer", _SE(js_cc_gfx_TextureSubresRange_baseArrayLayer_get), _SE(js_cc_gfx_TextureSubresRange_baseArrayLayer_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureSubresRange_layerCount_get), _SE(js_cc_gfx_TextureSubresRange_layerCount_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureSubresRange_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureSubresRange)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureSubresRange_proto = cls->getProto(); + __jsb_cc_gfx_TextureSubresRange_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureCopy_class = nullptr; +se::Object* __jsb_cc_gfx_TextureCopy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureCopy) + +static bool js_cc_gfx_TextureCopy_srcSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_srcSubres_set) + +static bool js_cc_gfx_TextureCopy_srcSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_srcSubres_get) + +static bool js_cc_gfx_TextureCopy_srcOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_srcOffset_set) + +static bool js_cc_gfx_TextureCopy_srcOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_srcOffset_get) + +static bool js_cc_gfx_TextureCopy_dstSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_dstSubres_set) + +static bool js_cc_gfx_TextureCopy_dstSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_dstSubres_get) + +static bool js_cc_gfx_TextureCopy_dstOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_dstOffset_set) + +static bool js_cc_gfx_TextureCopy_dstOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_dstOffset_get) + +static bool js_cc_gfx_TextureCopy_extent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->extent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_extent_set) + +static bool js_cc_gfx_TextureCopy_extent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->extent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->extent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_extent_get) + +static bool js_cc_gfx_TextureCopy_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + cc::gfx::TextureCopy *arg2 = 0 ; + cc::gfx::TextureCopy temp2 ; + cc::gfx::TextureCopy *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(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::gfx::TextureCopy *) &(arg1)->copy((cc::gfx::TextureCopy 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_gfx_TextureCopy_copy) + +static bool js_new_cc_gfx_TextureCopy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureCopy *result; + result = (cc::gfx::TextureCopy *)new cc::gfx::TextureCopy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureCopy, __jsb_cc_gfx_TextureCopy_class, js_delete_cc_gfx_TextureCopy) + +static bool js_delete_cc_gfx_TextureCopy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureCopy) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureCopy * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcSubres), ctx); + } + + + json->getProperty("srcOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcOffset), ctx); + } + + + json->getProperty("dstSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstSubres), ctx); + } + + + json->getProperty("dstOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstOffset), ctx); + } + + + json->getProperty("extent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->extent), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureCopy(se::Object* obj) { + auto* cls = se::Class::create("TextureCopy", obj, nullptr, _SE(js_new_cc_gfx_TextureCopy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcSubres", _SE(js_cc_gfx_TextureCopy_srcSubres_get), _SE(js_cc_gfx_TextureCopy_srcSubres_set)); + cls->defineProperty("srcOffset", _SE(js_cc_gfx_TextureCopy_srcOffset_get), _SE(js_cc_gfx_TextureCopy_srcOffset_set)); + cls->defineProperty("dstSubres", _SE(js_cc_gfx_TextureCopy_dstSubres_get), _SE(js_cc_gfx_TextureCopy_dstSubres_set)); + cls->defineProperty("dstOffset", _SE(js_cc_gfx_TextureCopy_dstOffset_get), _SE(js_cc_gfx_TextureCopy_dstOffset_set)); + cls->defineProperty("extent", _SE(js_cc_gfx_TextureCopy_extent_get), _SE(js_cc_gfx_TextureCopy_extent_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureCopy_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureCopy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureCopy_proto = cls->getProto(); + __jsb_cc_gfx_TextureCopy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureBlit_class = nullptr; +se::Object* __jsb_cc_gfx_TextureBlit_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureBlit) + +static bool js_cc_gfx_TextureBlit_srcSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_srcSubres_set) + +static bool js_cc_gfx_TextureBlit_srcSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_srcSubres_get) + +static bool js_cc_gfx_TextureBlit_srcOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_srcOffset_set) + +static bool js_cc_gfx_TextureBlit_srcOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_srcOffset_get) + +static bool js_cc_gfx_TextureBlit_srcExtent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcExtent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_srcExtent_set) + +static bool js_cc_gfx_TextureBlit_srcExtent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcExtent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcExtent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_srcExtent_get) + +static bool js_cc_gfx_TextureBlit_dstSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_dstSubres_set) + +static bool js_cc_gfx_TextureBlit_dstSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_dstSubres_get) + +static bool js_cc_gfx_TextureBlit_dstOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_dstOffset_set) + +static bool js_cc_gfx_TextureBlit_dstOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_dstOffset_get) + +static bool js_cc_gfx_TextureBlit_dstExtent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstExtent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_dstExtent_set) + +static bool js_cc_gfx_TextureBlit_dstExtent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstExtent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstExtent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_dstExtent_get) + +static bool js_cc_gfx_TextureBlit_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + cc::gfx::TextureBlit *arg2 = 0 ; + cc::gfx::TextureBlit temp2 ; + cc::gfx::TextureBlit *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(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::gfx::TextureBlit *) &(arg1)->copy((cc::gfx::TextureBlit 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_gfx_TextureBlit_copy) + +static bool js_new_cc_gfx_TextureBlit(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureBlit *result; + result = (cc::gfx::TextureBlit *)new cc::gfx::TextureBlit(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureBlit, __jsb_cc_gfx_TextureBlit_class, js_delete_cc_gfx_TextureBlit) + +static bool js_delete_cc_gfx_TextureBlit(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureBlit) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBlit * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcSubres), ctx); + } + + + json->getProperty("srcOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcOffset), ctx); + } + + + json->getProperty("srcExtent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcExtent), ctx); + } + + + json->getProperty("dstSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstSubres), ctx); + } + + + json->getProperty("dstOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstOffset), ctx); + } + + + json->getProperty("dstExtent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstExtent), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureBlit(se::Object* obj) { + auto* cls = se::Class::create("TextureBlit", obj, nullptr, _SE(js_new_cc_gfx_TextureBlit)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcSubres", _SE(js_cc_gfx_TextureBlit_srcSubres_get), _SE(js_cc_gfx_TextureBlit_srcSubres_set)); + cls->defineProperty("srcOffset", _SE(js_cc_gfx_TextureBlit_srcOffset_get), _SE(js_cc_gfx_TextureBlit_srcOffset_set)); + cls->defineProperty("srcExtent", _SE(js_cc_gfx_TextureBlit_srcExtent_get), _SE(js_cc_gfx_TextureBlit_srcExtent_set)); + cls->defineProperty("dstSubres", _SE(js_cc_gfx_TextureBlit_dstSubres_get), _SE(js_cc_gfx_TextureBlit_dstSubres_set)); + cls->defineProperty("dstOffset", _SE(js_cc_gfx_TextureBlit_dstOffset_get), _SE(js_cc_gfx_TextureBlit_dstOffset_set)); + cls->defineProperty("dstExtent", _SE(js_cc_gfx_TextureBlit_dstExtent_get), _SE(js_cc_gfx_TextureBlit_dstExtent_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureBlit_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureBlit)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureBlit_proto = cls->getProto(); + __jsb_cc_gfx_TextureBlit_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferTextureCopy_class = nullptr; +se::Object* __jsb_cc_gfx_BufferTextureCopy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferTextureCopy) + +static bool js_cc_gfx_BufferTextureCopy_buffOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_buffOffset_set) + +static bool js_cc_gfx_BufferTextureCopy_buffOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_buffOffset_get) + +static bool js_cc_gfx_BufferTextureCopy_buffStride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffStride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_buffStride_set) + +static bool js_cc_gfx_BufferTextureCopy_buffStride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffStride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_buffStride_get) + +static bool js_cc_gfx_BufferTextureCopy_buffTexHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffTexHeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_buffTexHeight_set) + +static bool js_cc_gfx_BufferTextureCopy_buffTexHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffTexHeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_buffTexHeight_get) + +static bool js_cc_gfx_BufferTextureCopy_texOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_texOffset_set) + +static bool js_cc_gfx_BufferTextureCopy_texOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_texOffset_get) + +static bool js_cc_gfx_BufferTextureCopy_texExtent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texExtent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_texExtent_set) + +static bool js_cc_gfx_BufferTextureCopy_texExtent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texExtent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texExtent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_texExtent_get) + +static bool js_cc_gfx_BufferTextureCopy_texSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_texSubres_set) + +static bool js_cc_gfx_BufferTextureCopy_texSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_texSubres_get) + +static bool js_cc_gfx_BufferTextureCopy_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + cc::gfx::BufferTextureCopy *arg2 = 0 ; + cc::gfx::BufferTextureCopy temp2 ; + cc::gfx::BufferTextureCopy *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(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::gfx::BufferTextureCopy *) &(arg1)->copy((cc::gfx::BufferTextureCopy 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_gfx_BufferTextureCopy_copy) + +static bool js_new_cc_gfx_BufferTextureCopy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferTextureCopy *result; + result = (cc::gfx::BufferTextureCopy *)new cc::gfx::BufferTextureCopy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferTextureCopy, __jsb_cc_gfx_BufferTextureCopy_class, js_delete_cc_gfx_BufferTextureCopy) + +static bool js_delete_cc_gfx_BufferTextureCopy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferTextureCopy) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferTextureCopy * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffOffset), ctx); + } + + + json->getProperty("buffStride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffStride), ctx); + } + + + json->getProperty("buffTexHeight", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffTexHeight), ctx); + } + + + json->getProperty("texOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texOffset), ctx); + } + + + json->getProperty("texExtent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texExtent), ctx); + } + + + json->getProperty("texSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texSubres), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferTextureCopy(se::Object* obj) { + auto* cls = se::Class::create("BufferTextureCopy", obj, nullptr, _SE(js_new_cc_gfx_BufferTextureCopy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffOffset", _SE(js_cc_gfx_BufferTextureCopy_buffOffset_get), _SE(js_cc_gfx_BufferTextureCopy_buffOffset_set)); + cls->defineProperty("buffStride", _SE(js_cc_gfx_BufferTextureCopy_buffStride_get), _SE(js_cc_gfx_BufferTextureCopy_buffStride_set)); + cls->defineProperty("buffTexHeight", _SE(js_cc_gfx_BufferTextureCopy_buffTexHeight_get), _SE(js_cc_gfx_BufferTextureCopy_buffTexHeight_set)); + cls->defineProperty("texOffset", _SE(js_cc_gfx_BufferTextureCopy_texOffset_get), _SE(js_cc_gfx_BufferTextureCopy_texOffset_set)); + cls->defineProperty("texExtent", _SE(js_cc_gfx_BufferTextureCopy_texExtent_get), _SE(js_cc_gfx_BufferTextureCopy_texExtent_set)); + cls->defineProperty("texSubres", _SE(js_cc_gfx_BufferTextureCopy_texSubres_get), _SE(js_cc_gfx_BufferTextureCopy_texSubres_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferTextureCopy_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferTextureCopy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferTextureCopy_proto = cls->getProto(); + __jsb_cc_gfx_BufferTextureCopy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Viewport_class = nullptr; +se::Object* __jsb_cc_gfx_Viewport_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Viewport) + +static bool js_cc_gfx_Viewport_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_left_set) + +static bool js_cc_gfx_Viewport_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_left_get) + +static bool js_cc_gfx_Viewport_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_top_set) + +static bool js_cc_gfx_Viewport_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_top_get) + +static bool js_cc_gfx_Viewport_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_width_set) + +static bool js_cc_gfx_Viewport_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_width_get) + +static bool js_cc_gfx_Viewport_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_height_set) + +static bool js_cc_gfx_Viewport_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_height_get) + +static bool js_cc_gfx_Viewport_minDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minDepth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_minDepth_set) + +static bool js_cc_gfx_Viewport_minDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minDepth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_minDepth_get) + +static bool js_cc_gfx_Viewport_maxDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxDepth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_maxDepth_set) + +static bool js_cc_gfx_Viewport_maxDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxDepth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_maxDepth_get) + +static bool js_cc_gfx_Viewport_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + cc::gfx::Viewport *arg2 = 0 ; + cc::gfx::Viewport temp2 ; + cc::gfx::Viewport *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(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::gfx::Viewport *) &(arg1)->copy((cc::gfx::Viewport 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_gfx_Viewport_copy) + +static bool js_cc_gfx_Viewport_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Viewport_reset) + +static bool js_new_cc_gfx_Viewport(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Viewport *result; + result = (cc::gfx::Viewport *)new cc::gfx::Viewport(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Viewport, __jsb_cc_gfx_Viewport_class, js_delete_cc_gfx_Viewport) + +static bool js_delete_cc_gfx_Viewport(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Viewport) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Viewport * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("minDepth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minDepth), ctx); + } + + + json->getProperty("maxDepth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxDepth), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Viewport(se::Object* obj) { + auto* cls = se::Class::create("Viewport", obj, nullptr, _SE(js_new_cc_gfx_Viewport)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("left", _SE(js_cc_gfx_Viewport_left_get), _SE(js_cc_gfx_Viewport_left_set)); + cls->defineProperty("top", _SE(js_cc_gfx_Viewport_top_get), _SE(js_cc_gfx_Viewport_top_set)); + cls->defineProperty("width", _SE(js_cc_gfx_Viewport_width_get), _SE(js_cc_gfx_Viewport_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_Viewport_height_get), _SE(js_cc_gfx_Viewport_height_set)); + cls->defineProperty("minDepth", _SE(js_cc_gfx_Viewport_minDepth_get), _SE(js_cc_gfx_Viewport_minDepth_set)); + cls->defineProperty("maxDepth", _SE(js_cc_gfx_Viewport_maxDepth_get), _SE(js_cc_gfx_Viewport_maxDepth_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Viewport_copy)); + cls->defineFunction("reset", _SE(js_cc_gfx_Viewport_reset)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Viewport)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Viewport_proto = cls->getProto(); + __jsb_cc_gfx_Viewport_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Color_class = nullptr; +se::Object* __jsb_cc_gfx_Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Color) + +static bool js_cc_gfx_Color_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_x_set) + +static bool js_cc_gfx_Color_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_x_get) + +static bool js_cc_gfx_Color_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_y_set) + +static bool js_cc_gfx_Color_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_y_get) + +static bool js_cc_gfx_Color_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_z_set) + +static bool js_cc_gfx_Color_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_z_get) + +static bool js_cc_gfx_Color_w_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->w, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_w_set) + +static bool js_cc_gfx_Color_w_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->w, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_w_get) + +static bool js_cc_gfx_Color_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + cc::gfx::Color *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(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::gfx::Color *) &(arg1)->copy((cc::gfx::Color 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_gfx_Color_copy) + +static bool js_new_cc_gfx_Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Color *result; + result = (cc::gfx::Color *)new cc::gfx::Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Color, __jsb_cc_gfx_Color_class, js_delete_cc_gfx_Color) + +static bool js_delete_cc_gfx_Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Color) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Color * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + json->getProperty("w", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->w), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_cc_gfx_Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Color_x_get), _SE(js_cc_gfx_Color_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Color_y_get), _SE(js_cc_gfx_Color_y_set)); + cls->defineProperty("z", _SE(js_cc_gfx_Color_z_get), _SE(js_cc_gfx_Color_z_set)); + cls->defineProperty("w", _SE(js_cc_gfx_Color_w_get), _SE(js_cc_gfx_Color_w_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Color_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Color_proto = cls->getProto(); + __jsb_cc_gfx_Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_MarkerInfo_class = nullptr; +se::Object* __jsb_cc_gfx_MarkerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_MarkerInfo) + +static bool js_cc_gfx_MarkerInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MarkerInfo_name_set) + +static bool js_cc_gfx_MarkerInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MarkerInfo_name_get) + +static bool js_cc_gfx_MarkerInfo_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MarkerInfo_color_set) + +static bool js_cc_gfx_MarkerInfo_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MarkerInfo_color_get) + +static bool js_new_cc_gfx_MarkerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::MarkerInfo *result; + result = (cc::gfx::MarkerInfo *)new cc::gfx::MarkerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_MarkerInfo, __jsb_cc_gfx_MarkerInfo_class, js_delete_cc_gfx_MarkerInfo) + +static bool js_delete_cc_gfx_MarkerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_MarkerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MarkerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("color", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->color), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_MarkerInfo(se::Object* obj) { + auto* cls = se::Class::create("MarkerInfo", obj, nullptr, _SE(js_new_cc_gfx_MarkerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_MarkerInfo_name_get), _SE(js_cc_gfx_MarkerInfo_name_set)); + cls->defineProperty("color", _SE(js_cc_gfx_MarkerInfo_color_get), _SE(js_cc_gfx_MarkerInfo_color_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_MarkerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_MarkerInfo_proto = cls->getProto(); + __jsb_cc_gfx_MarkerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BindingMappingInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BindingMappingInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BindingMappingInfo) + +static bool js_cc_gfx_BindingMappingInfo_maxBlockCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxBlockCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxBlockCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxBlockCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxBlockCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxBlockCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxBlockCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSamplerTextureCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSamplerTextureCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxSamplerTextureCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSamplerCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSamplerCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxSamplerCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxTextureCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTextureCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxTextureCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxTextureCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTextureCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxTextureCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxTextureCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxBufferCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxBufferCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxBufferCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxBufferCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxBufferCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxBufferCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxBufferCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxImageCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxImageCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxImageCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxImageCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxImageCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxImageCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxImageCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubpassInputCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubpassInputCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxSubpassInputCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_setIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->setIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_setIndices_set) + +static bool js_cc_gfx_BindingMappingInfo_setIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->setIndices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->setIndices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_setIndices_get) + +static bool js_cc_gfx_BindingMappingInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + cc::gfx::BindingMappingInfo *arg2 = 0 ; + cc::gfx::BindingMappingInfo temp2 ; + cc::gfx::BindingMappingInfo *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(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::gfx::BindingMappingInfo *) &(arg1)->copy((cc::gfx::BindingMappingInfo 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_gfx_BindingMappingInfo_copy) + +static bool js_new_cc_gfx_BindingMappingInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BindingMappingInfo *result; + result = (cc::gfx::BindingMappingInfo *)new cc::gfx::BindingMappingInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BindingMappingInfo, __jsb_cc_gfx_BindingMappingInfo_class, js_delete_cc_gfx_BindingMappingInfo) + +static bool js_delete_cc_gfx_BindingMappingInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BindingMappingInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BindingMappingInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxBlockCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxBlockCounts), ctx); + } + + + json->getProperty("maxSamplerTextureCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSamplerTextureCounts), ctx); + } + + + json->getProperty("maxSamplerCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSamplerCounts), ctx); + } + + + json->getProperty("maxTextureCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTextureCounts), ctx); + } + + + json->getProperty("maxBufferCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxBufferCounts), ctx); + } + + + json->getProperty("maxImageCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxImageCounts), ctx); + } + + + json->getProperty("maxSubpassInputCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubpassInputCounts), ctx); + } + + + json->getProperty("setIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->setIndices), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BindingMappingInfo(se::Object* obj) { + auto* cls = se::Class::create("BindingMappingInfo", obj, nullptr, _SE(js_new_cc_gfx_BindingMappingInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxBlockCounts", _SE(js_cc_gfx_BindingMappingInfo_maxBlockCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxBlockCounts_set)); + cls->defineProperty("maxSamplerTextureCounts", _SE(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_set)); + cls->defineProperty("maxSamplerCounts", _SE(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_set)); + cls->defineProperty("maxTextureCounts", _SE(js_cc_gfx_BindingMappingInfo_maxTextureCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxTextureCounts_set)); + cls->defineProperty("maxBufferCounts", _SE(js_cc_gfx_BindingMappingInfo_maxBufferCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxBufferCounts_set)); + cls->defineProperty("maxImageCounts", _SE(js_cc_gfx_BindingMappingInfo_maxImageCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxImageCounts_set)); + cls->defineProperty("maxSubpassInputCounts", _SE(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_set)); + cls->defineProperty("setIndices", _SE(js_cc_gfx_BindingMappingInfo_setIndices_get), _SE(js_cc_gfx_BindingMappingInfo_setIndices_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BindingMappingInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BindingMappingInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BindingMappingInfo_proto = cls->getProto(); + __jsb_cc_gfx_BindingMappingInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SwapchainInfo_class = nullptr; +se::Object* __jsb_cc_gfx_SwapchainInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SwapchainInfo) + +static bool js_cc_gfx_SwapchainInfo_windowId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->windowId, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_windowId_set) + +static bool js_cc_gfx_SwapchainInfo_windowId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->windowId, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_windowId_get) + +static bool js_cc_gfx_SwapchainInfo_windowHandle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->windowHandle); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_windowHandle_set) + +static bool js_cc_gfx_SwapchainInfo_windowHandle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->windowHandle, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->windowHandle, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_windowHandle_get) + +static bool js_cc_gfx_SwapchainInfo_vsyncMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vsyncMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_vsyncMode_set) + +static bool js_cc_gfx_SwapchainInfo_vsyncMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vsyncMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vsyncMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_vsyncMode_get) + +static bool js_cc_gfx_SwapchainInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_width_set) + +static bool js_cc_gfx_SwapchainInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_width_get) + +static bool js_cc_gfx_SwapchainInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_height_set) + +static bool js_cc_gfx_SwapchainInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_height_get) + +static bool js_cc_gfx_SwapchainInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + cc::gfx::SwapchainInfo *arg2 = 0 ; + cc::gfx::SwapchainInfo temp2 ; + cc::gfx::SwapchainInfo *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(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::gfx::SwapchainInfo *) &(arg1)->copy((cc::gfx::SwapchainInfo 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_gfx_SwapchainInfo_copy) + +static bool js_new_cc_gfx_SwapchainInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SwapchainInfo *result; + result = (cc::gfx::SwapchainInfo *)new cc::gfx::SwapchainInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SwapchainInfo, __jsb_cc_gfx_SwapchainInfo_class, js_delete_cc_gfx_SwapchainInfo) + +static bool js_delete_cc_gfx_SwapchainInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SwapchainInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SwapchainInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("windowId", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->windowId), ctx); + } + + + json->getProperty("windowHandle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->windowHandle), ctx); + } + + + json->getProperty("vsyncMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vsyncMode), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SwapchainInfo(se::Object* obj) { + auto* cls = se::Class::create("SwapchainInfo", obj, nullptr, _SE(js_new_cc_gfx_SwapchainInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("windowId", _SE(js_cc_gfx_SwapchainInfo_windowId_get), _SE(js_cc_gfx_SwapchainInfo_windowId_set)); + cls->defineProperty("windowHandle", _SE(js_cc_gfx_SwapchainInfo_windowHandle_get), _SE(js_cc_gfx_SwapchainInfo_windowHandle_set)); + cls->defineProperty("vsyncMode", _SE(js_cc_gfx_SwapchainInfo_vsyncMode_get), _SE(js_cc_gfx_SwapchainInfo_vsyncMode_set)); + cls->defineProperty("width", _SE(js_cc_gfx_SwapchainInfo_width_get), _SE(js_cc_gfx_SwapchainInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_SwapchainInfo_height_get), _SE(js_cc_gfx_SwapchainInfo_height_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SwapchainInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SwapchainInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SwapchainInfo_proto = cls->getProto(); + __jsb_cc_gfx_SwapchainInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceInfo) + +static bool js_cc_gfx_DeviceInfo_bindingMappingInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceInfo *arg1 = (cc::gfx::DeviceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindingMappingInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceInfo_bindingMappingInfo_set) + +static bool js_cc_gfx_DeviceInfo_bindingMappingInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceInfo *arg1 = (cc::gfx::DeviceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindingMappingInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindingMappingInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceInfo_bindingMappingInfo_get) + +static bool js_cc_gfx_DeviceInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceInfo *arg1 = (cc::gfx::DeviceInfo *) NULL ; + cc::gfx::DeviceInfo *arg2 = 0 ; + cc::gfx::DeviceInfo temp2 ; + cc::gfx::DeviceInfo *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(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::gfx::DeviceInfo *) &(arg1)->copy((cc::gfx::DeviceInfo 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_gfx_DeviceInfo_copy) + +static bool js_new_cc_gfx_DeviceInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceInfo *result; + result = (cc::gfx::DeviceInfo *)new cc::gfx::DeviceInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceInfo, __jsb_cc_gfx_DeviceInfo_class, js_delete_cc_gfx_DeviceInfo) + +static bool js_delete_cc_gfx_DeviceInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bindingMappingInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindingMappingInfo), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DeviceInfo(se::Object* obj) { + auto* cls = se::Class::create("DeviceInfo", obj, nullptr, _SE(js_new_cc_gfx_DeviceInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindingMappingInfo", _SE(js_cc_gfx_DeviceInfo_bindingMappingInfo_get), _SE(js_cc_gfx_DeviceInfo_bindingMappingInfo_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DeviceInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceInfo_proto = cls->getProto(); + __jsb_cc_gfx_DeviceInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferInfo) + +static bool js_cc_gfx_BufferInfo_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_usage_set) + +static bool js_cc_gfx_BufferInfo_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_usage_get) + +static bool js_cc_gfx_BufferInfo_memUsage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memUsage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_memUsage_set) + +static bool js_cc_gfx_BufferInfo_memUsage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memUsage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memUsage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_memUsage_get) + +static bool js_cc_gfx_BufferInfo_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_size_set) + +static bool js_cc_gfx_BufferInfo_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_size_get) + +static bool js_cc_gfx_BufferInfo_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_stride_set) + +static bool js_cc_gfx_BufferInfo_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_stride_get) + +static bool js_cc_gfx_BufferInfo_flags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_flags_set) + +static bool js_cc_gfx_BufferInfo_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->flags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_flags_get) + +static bool js_cc_gfx_BufferInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + cc::gfx::BufferInfo *arg2 = 0 ; + cc::gfx::BufferInfo temp2 ; + cc::gfx::BufferInfo *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(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::gfx::BufferInfo *) &(arg1)->copy((cc::gfx::BufferInfo 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_gfx_BufferInfo_copy) + +static bool js_new_cc_gfx_BufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferInfo *result; + result = (cc::gfx::BufferInfo *)new cc::gfx::BufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferInfo, __jsb_cc_gfx_BufferInfo_class, js_delete_cc_gfx_BufferInfo) + +static bool js_delete_cc_gfx_BufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + json->getProperty("memUsage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memUsage), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + json->getProperty("flags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flags), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferInfo(se::Object* obj) { + auto* cls = se::Class::create("BufferInfo", obj, nullptr, _SE(js_new_cc_gfx_BufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("usage", _SE(js_cc_gfx_BufferInfo_usage_get), _SE(js_cc_gfx_BufferInfo_usage_set)); + cls->defineProperty("memUsage", _SE(js_cc_gfx_BufferInfo_memUsage_get), _SE(js_cc_gfx_BufferInfo_memUsage_set)); + cls->defineProperty("size", _SE(js_cc_gfx_BufferInfo_size_get), _SE(js_cc_gfx_BufferInfo_size_set)); + cls->defineProperty("stride", _SE(js_cc_gfx_BufferInfo_stride_get), _SE(js_cc_gfx_BufferInfo_stride_set)); + cls->defineProperty("flags", _SE(js_cc_gfx_BufferInfo_flags_get), _SE(js_cc_gfx_BufferInfo_flags_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferInfo_proto = cls->getProto(); + __jsb_cc_gfx_BufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferViewInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BufferViewInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferViewInfo) + +static bool js_cc_gfx_BufferViewInfo_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferViewInfo_buffer_set) + +static bool js_cc_gfx_BufferViewInfo_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferViewInfo_buffer_get) + +static bool js_cc_gfx_BufferViewInfo_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferViewInfo_offset_set) + +static bool js_cc_gfx_BufferViewInfo_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferViewInfo_offset_get) + +static bool js_cc_gfx_BufferViewInfo_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->range, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferViewInfo_range_set) + +static bool js_cc_gfx_BufferViewInfo_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->range, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferViewInfo_range_get) + +static bool js_cc_gfx_BufferViewInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + cc::gfx::BufferViewInfo *arg2 = 0 ; + cc::gfx::BufferViewInfo temp2 ; + cc::gfx::BufferViewInfo *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(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::gfx::BufferViewInfo *) &(arg1)->copy((cc::gfx::BufferViewInfo 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_gfx_BufferViewInfo_copy) + +static bool js_new_cc_gfx_BufferViewInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferViewInfo *result; + result = (cc::gfx::BufferViewInfo *)new cc::gfx::BufferViewInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferViewInfo, __jsb_cc_gfx_BufferViewInfo_class, js_delete_cc_gfx_BufferViewInfo) + +static bool js_delete_cc_gfx_BufferViewInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferViewInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferViewInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("range", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->range), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferViewInfo(se::Object* obj) { + auto* cls = se::Class::create("BufferViewInfo", obj, nullptr, _SE(js_new_cc_gfx_BufferViewInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffer", _SE(js_cc_gfx_BufferViewInfo_buffer_get), _SE(js_cc_gfx_BufferViewInfo_buffer_set)); + cls->defineProperty("offset", _SE(js_cc_gfx_BufferViewInfo_offset_get), _SE(js_cc_gfx_BufferViewInfo_offset_set)); + cls->defineProperty("range", _SE(js_cc_gfx_BufferViewInfo_range_get), _SE(js_cc_gfx_BufferViewInfo_range_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferViewInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferViewInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferViewInfo_proto = cls->getProto(); + __jsb_cc_gfx_BufferViewInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DrawInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DrawInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DrawInfo) + +static bool js_cc_gfx_DrawInfo_vertexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_vertexCount_set) + +static bool js_cc_gfx_DrawInfo_vertexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_vertexCount_get) + +static bool js_cc_gfx_DrawInfo_firstVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstVertex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_firstVertex_set) + +static bool js_cc_gfx_DrawInfo_firstVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstVertex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_firstVertex_get) + +static bool js_cc_gfx_DrawInfo_indexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_indexCount_set) + +static bool js_cc_gfx_DrawInfo_indexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_indexCount_get) + +static bool js_cc_gfx_DrawInfo_firstIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_firstIndex_set) + +static bool js_cc_gfx_DrawInfo_firstIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_firstIndex_get) + +static bool js_cc_gfx_DrawInfo_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_vertexOffset_set) + +static bool js_cc_gfx_DrawInfo_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_vertexOffset_get) + +static bool js_cc_gfx_DrawInfo_instanceCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->instanceCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_instanceCount_set) + +static bool js_cc_gfx_DrawInfo_instanceCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->instanceCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_instanceCount_get) + +static bool js_cc_gfx_DrawInfo_firstInstance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstInstance, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_firstInstance_set) + +static bool js_cc_gfx_DrawInfo_firstInstance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstInstance, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_firstInstance_get) + +static bool js_cc_gfx_DrawInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::gfx::DrawInfo temp2 ; + cc::gfx::DrawInfo *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(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::gfx::DrawInfo *) &(arg1)->copy((cc::gfx::DrawInfo 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_gfx_DrawInfo_copy) + +static bool js_new_cc_gfx_DrawInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DrawInfo *result; + result = (cc::gfx::DrawInfo *)new cc::gfx::DrawInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DrawInfo, __jsb_cc_gfx_DrawInfo_class, js_delete_cc_gfx_DrawInfo) + +static bool js_delete_cc_gfx_DrawInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DrawInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DrawInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vertexCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexCount), ctx); + } + + + json->getProperty("firstVertex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstVertex), ctx); + } + + + json->getProperty("indexCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexCount), ctx); + } + + + json->getProperty("firstIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstIndex), ctx); + } + + + json->getProperty("vertexOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexOffset), ctx); + } + + + json->getProperty("instanceCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->instanceCount), ctx); + } + + + json->getProperty("firstInstance", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstInstance), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DrawInfo(se::Object* obj) { + auto* cls = se::Class::create("DrawInfo", obj, nullptr, _SE(js_new_cc_gfx_DrawInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexCount", _SE(js_cc_gfx_DrawInfo_vertexCount_get), _SE(js_cc_gfx_DrawInfo_vertexCount_set)); + cls->defineProperty("firstVertex", _SE(js_cc_gfx_DrawInfo_firstVertex_get), _SE(js_cc_gfx_DrawInfo_firstVertex_set)); + cls->defineProperty("indexCount", _SE(js_cc_gfx_DrawInfo_indexCount_get), _SE(js_cc_gfx_DrawInfo_indexCount_set)); + cls->defineProperty("firstIndex", _SE(js_cc_gfx_DrawInfo_firstIndex_get), _SE(js_cc_gfx_DrawInfo_firstIndex_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_gfx_DrawInfo_vertexOffset_get), _SE(js_cc_gfx_DrawInfo_vertexOffset_set)); + cls->defineProperty("instanceCount", _SE(js_cc_gfx_DrawInfo_instanceCount_get), _SE(js_cc_gfx_DrawInfo_instanceCount_set)); + cls->defineProperty("firstInstance", _SE(js_cc_gfx_DrawInfo_firstInstance_get), _SE(js_cc_gfx_DrawInfo_firstInstance_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DrawInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DrawInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DrawInfo_proto = cls->getProto(); + __jsb_cc_gfx_DrawInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DispatchInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DispatchInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DispatchInfo) + +static bool js_cc_gfx_DispatchInfo_groupCountX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupCountX, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_groupCountX_set) + +static bool js_cc_gfx_DispatchInfo_groupCountX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupCountX, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_groupCountX_get) + +static bool js_cc_gfx_DispatchInfo_groupCountY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupCountY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_groupCountY_set) + +static bool js_cc_gfx_DispatchInfo_groupCountY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupCountY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_groupCountY_get) + +static bool js_cc_gfx_DispatchInfo_groupCountZ_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupCountZ, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_groupCountZ_set) + +static bool js_cc_gfx_DispatchInfo_groupCountZ_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupCountZ, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_groupCountZ_get) + +static bool js_cc_gfx_DispatchInfo_indirectBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indirectBuffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_indirectBuffer_set) + +static bool js_cc_gfx_DispatchInfo_indirectBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indirectBuffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indirectBuffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_indirectBuffer_get) + +static bool js_cc_gfx_DispatchInfo_indirectOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indirectOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_indirectOffset_set) + +static bool js_cc_gfx_DispatchInfo_indirectOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indirectOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_indirectOffset_get) + +static bool js_cc_gfx_DispatchInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + cc::gfx::DispatchInfo *arg2 = 0 ; + cc::gfx::DispatchInfo temp2 ; + cc::gfx::DispatchInfo *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(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::gfx::DispatchInfo *) &(arg1)->copy((cc::gfx::DispatchInfo 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_gfx_DispatchInfo_copy) + +static bool js_new_cc_gfx_DispatchInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DispatchInfo *result; + result = (cc::gfx::DispatchInfo *)new cc::gfx::DispatchInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DispatchInfo, __jsb_cc_gfx_DispatchInfo_class, js_delete_cc_gfx_DispatchInfo) + +static bool js_delete_cc_gfx_DispatchInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DispatchInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DispatchInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("groupCountX", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupCountX), ctx); + } + + + json->getProperty("groupCountY", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupCountY), ctx); + } + + + json->getProperty("groupCountZ", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupCountZ), ctx); + } + + + json->getProperty("indirectBuffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indirectBuffer), ctx); + } + + + json->getProperty("indirectOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indirectOffset), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DispatchInfo(se::Object* obj) { + auto* cls = se::Class::create("DispatchInfo", obj, nullptr, _SE(js_new_cc_gfx_DispatchInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("groupCountX", _SE(js_cc_gfx_DispatchInfo_groupCountX_get), _SE(js_cc_gfx_DispatchInfo_groupCountX_set)); + cls->defineProperty("groupCountY", _SE(js_cc_gfx_DispatchInfo_groupCountY_get), _SE(js_cc_gfx_DispatchInfo_groupCountY_set)); + cls->defineProperty("groupCountZ", _SE(js_cc_gfx_DispatchInfo_groupCountZ_get), _SE(js_cc_gfx_DispatchInfo_groupCountZ_set)); + cls->defineProperty("indirectBuffer", _SE(js_cc_gfx_DispatchInfo_indirectBuffer_get), _SE(js_cc_gfx_DispatchInfo_indirectBuffer_set)); + cls->defineProperty("indirectOffset", _SE(js_cc_gfx_DispatchInfo_indirectOffset_get), _SE(js_cc_gfx_DispatchInfo_indirectOffset_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DispatchInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DispatchInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DispatchInfo_proto = cls->getProto(); + __jsb_cc_gfx_DispatchInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_IndirectBuffer_class = nullptr; +se::Object* __jsb_cc_gfx_IndirectBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_IndirectBuffer) + +static bool js_cc_gfx_IndirectBuffer_drawInfos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::IndirectBuffer *arg1 = (cc::gfx::IndirectBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->drawInfos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_IndirectBuffer_drawInfos_set) + +static bool js_cc_gfx_IndirectBuffer_drawInfos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::IndirectBuffer *arg1 = (cc::gfx::IndirectBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->drawInfos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->drawInfos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_IndirectBuffer_drawInfos_get) + +static bool js_cc_gfx_IndirectBuffer_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::IndirectBuffer *arg1 = (cc::gfx::IndirectBuffer *) NULL ; + cc::gfx::IndirectBuffer *arg2 = 0 ; + cc::gfx::IndirectBuffer temp2 ; + cc::gfx::IndirectBuffer *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(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::gfx::IndirectBuffer *) &(arg1)->copy((cc::gfx::IndirectBuffer 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_gfx_IndirectBuffer_copy) + +static bool js_new_cc_gfx_IndirectBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::IndirectBuffer *result; + result = (cc::gfx::IndirectBuffer *)new cc::gfx::IndirectBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_IndirectBuffer, __jsb_cc_gfx_IndirectBuffer_class, js_delete_cc_gfx_IndirectBuffer) + +static bool js_delete_cc_gfx_IndirectBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_IndirectBuffer) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::IndirectBuffer * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("drawInfos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->drawInfos), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_IndirectBuffer(se::Object* obj) { + auto* cls = se::Class::create("IndirectBuffer", obj, nullptr, _SE(js_new_cc_gfx_IndirectBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("drawInfos", _SE(js_cc_gfx_IndirectBuffer_drawInfos_get), _SE(js_cc_gfx_IndirectBuffer_drawInfos_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_IndirectBuffer_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_IndirectBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_IndirectBuffer_proto = cls->getProto(); + __jsb_cc_gfx_IndirectBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureInfo_class = nullptr; +se::Object* __jsb_cc_gfx_TextureInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureInfo) + +static bool js_cc_gfx_TextureInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_type_set) + +static bool js_cc_gfx_TextureInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_type_get) + +static bool js_cc_gfx_TextureInfo_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_usage_set) + +static bool js_cc_gfx_TextureInfo_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_usage_get) + +static bool js_cc_gfx_TextureInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_format_set) + +static bool js_cc_gfx_TextureInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_format_get) + +static bool js_cc_gfx_TextureInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_width_set) + +static bool js_cc_gfx_TextureInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_width_get) + +static bool js_cc_gfx_TextureInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_height_set) + +static bool js_cc_gfx_TextureInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_height_get) + +static bool js_cc_gfx_TextureInfo_flags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_flags_set) + +static bool js_cc_gfx_TextureInfo_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->flags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_flags_get) + +static bool js_cc_gfx_TextureInfo_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_layerCount_set) + +static bool js_cc_gfx_TextureInfo_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_layerCount_get) + +static bool js_cc_gfx_TextureInfo_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_levelCount_set) + +static bool js_cc_gfx_TextureInfo_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_levelCount_get) + +static bool js_cc_gfx_TextureInfo_samples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samples, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_samples_set) + +static bool js_cc_gfx_TextureInfo_samples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samples, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samples, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_samples_get) + +static bool js_cc_gfx_TextureInfo_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_depth_set) + +static bool js_cc_gfx_TextureInfo_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_depth_get) + +static bool js_cc_gfx_TextureInfo_externalRes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->externalRes); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_externalRes_set) + +static bool js_cc_gfx_TextureInfo_externalRes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalRes, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalRes, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_externalRes_get) + +static bool js_cc_gfx_TextureInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + cc::gfx::TextureInfo *arg2 = 0 ; + cc::gfx::TextureInfo temp2 ; + cc::gfx::TextureInfo *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(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::gfx::TextureInfo *) &(arg1)->copy((cc::gfx::TextureInfo 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_gfx_TextureInfo_copy) + +static bool js_new_cc_gfx_TextureInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureInfo *result; + result = (cc::gfx::TextureInfo *)new cc::gfx::TextureInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureInfo, __jsb_cc_gfx_TextureInfo_class, js_delete_cc_gfx_TextureInfo) + +static bool js_delete_cc_gfx_TextureInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("flags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flags), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("samples", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samples), ctx); + } + + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + json->getProperty("externalRes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalRes), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureInfo", obj, nullptr, _SE(js_new_cc_gfx_TextureInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_TextureInfo_type_get), _SE(js_cc_gfx_TextureInfo_type_set)); + cls->defineProperty("usage", _SE(js_cc_gfx_TextureInfo_usage_get), _SE(js_cc_gfx_TextureInfo_usage_set)); + cls->defineProperty("format", _SE(js_cc_gfx_TextureInfo_format_get), _SE(js_cc_gfx_TextureInfo_format_set)); + cls->defineProperty("width", _SE(js_cc_gfx_TextureInfo_width_get), _SE(js_cc_gfx_TextureInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_TextureInfo_height_get), _SE(js_cc_gfx_TextureInfo_height_set)); + cls->defineProperty("flags", _SE(js_cc_gfx_TextureInfo_flags_get), _SE(js_cc_gfx_TextureInfo_flags_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureInfo_layerCount_get), _SE(js_cc_gfx_TextureInfo_layerCount_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_TextureInfo_levelCount_get), _SE(js_cc_gfx_TextureInfo_levelCount_set)); + cls->defineProperty("samples", _SE(js_cc_gfx_TextureInfo_samples_get), _SE(js_cc_gfx_TextureInfo_samples_set)); + cls->defineProperty("depth", _SE(js_cc_gfx_TextureInfo_depth_get), _SE(js_cc_gfx_TextureInfo_depth_set)); + cls->defineProperty("externalRes", _SE(js_cc_gfx_TextureInfo_externalRes_get), _SE(js_cc_gfx_TextureInfo_externalRes_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureInfo_proto = cls->getProto(); + __jsb_cc_gfx_TextureInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureViewInfo_class = nullptr; +se::Object* __jsb_cc_gfx_TextureViewInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureViewInfo) + +static bool js_cc_gfx_TextureViewInfo_texture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_texture_set) + +static bool js_cc_gfx_TextureViewInfo_texture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_texture_get) + +static bool js_cc_gfx_TextureViewInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_type_set) + +static bool js_cc_gfx_TextureViewInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_type_get) + +static bool js_cc_gfx_TextureViewInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_format_set) + +static bool js_cc_gfx_TextureViewInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_format_get) + +static bool js_cc_gfx_TextureViewInfo_baseLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_baseLevel_set) + +static bool js_cc_gfx_TextureViewInfo_baseLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_baseLevel_get) + +static bool js_cc_gfx_TextureViewInfo_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_levelCount_set) + +static bool js_cc_gfx_TextureViewInfo_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_levelCount_get) + +static bool js_cc_gfx_TextureViewInfo_baseLayer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseLayer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_baseLayer_set) + +static bool js_cc_gfx_TextureViewInfo_baseLayer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseLayer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_baseLayer_get) + +static bool js_cc_gfx_TextureViewInfo_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_layerCount_set) + +static bool js_cc_gfx_TextureViewInfo_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_layerCount_get) + +static bool js_cc_gfx_TextureViewInfo_basePlane_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->basePlane, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_basePlane_set) + +static bool js_cc_gfx_TextureViewInfo_basePlane_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->basePlane, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_basePlane_get) + +static bool js_cc_gfx_TextureViewInfo_planeCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->planeCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_planeCount_set) + +static bool js_cc_gfx_TextureViewInfo_planeCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->planeCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_planeCount_get) + +static bool js_cc_gfx_TextureViewInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + cc::gfx::TextureViewInfo *arg2 = 0 ; + cc::gfx::TextureViewInfo temp2 ; + cc::gfx::TextureViewInfo *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(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::gfx::TextureViewInfo *) &(arg1)->copy((cc::gfx::TextureViewInfo 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_gfx_TextureViewInfo_copy) + +static bool js_new_cc_gfx_TextureViewInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureViewInfo *result; + result = (cc::gfx::TextureViewInfo *)new cc::gfx::TextureViewInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureViewInfo, __jsb_cc_gfx_TextureViewInfo_class, js_delete_cc_gfx_TextureViewInfo) + +static bool js_delete_cc_gfx_TextureViewInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureViewInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureViewInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("texture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texture), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("baseLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseLevel), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("baseLayer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseLayer), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + json->getProperty("basePlane", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->basePlane), ctx); + } + + + json->getProperty("planeCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->planeCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureViewInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureViewInfo", obj, nullptr, _SE(js_new_cc_gfx_TextureViewInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("texture", _SE(js_cc_gfx_TextureViewInfo_texture_get), _SE(js_cc_gfx_TextureViewInfo_texture_set)); + cls->defineProperty("type", _SE(js_cc_gfx_TextureViewInfo_type_get), _SE(js_cc_gfx_TextureViewInfo_type_set)); + cls->defineProperty("format", _SE(js_cc_gfx_TextureViewInfo_format_get), _SE(js_cc_gfx_TextureViewInfo_format_set)); + cls->defineProperty("baseLevel", _SE(js_cc_gfx_TextureViewInfo_baseLevel_get), _SE(js_cc_gfx_TextureViewInfo_baseLevel_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_TextureViewInfo_levelCount_get), _SE(js_cc_gfx_TextureViewInfo_levelCount_set)); + cls->defineProperty("baseLayer", _SE(js_cc_gfx_TextureViewInfo_baseLayer_get), _SE(js_cc_gfx_TextureViewInfo_baseLayer_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureViewInfo_layerCount_get), _SE(js_cc_gfx_TextureViewInfo_layerCount_set)); + cls->defineProperty("basePlane", _SE(js_cc_gfx_TextureViewInfo_basePlane_get), _SE(js_cc_gfx_TextureViewInfo_basePlane_set)); + cls->defineProperty("planeCount", _SE(js_cc_gfx_TextureViewInfo_planeCount_get), _SE(js_cc_gfx_TextureViewInfo_planeCount_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureViewInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureViewInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureViewInfo_proto = cls->getProto(); + __jsb_cc_gfx_TextureViewInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SamplerInfo_class = nullptr; +se::Object* __jsb_cc_gfx_SamplerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SamplerInfo) + +static bool js_cc_gfx_SamplerInfo_minFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_minFilter_set) + +static bool js_cc_gfx_SamplerInfo_minFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_minFilter_get) + +static bool js_cc_gfx_SamplerInfo_magFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->magFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_magFilter_set) + +static bool js_cc_gfx_SamplerInfo_magFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->magFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->magFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_magFilter_get) + +static bool js_cc_gfx_SamplerInfo_mipFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_mipFilter_set) + +static bool js_cc_gfx_SamplerInfo_mipFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_mipFilter_get) + +static bool js_cc_gfx_SamplerInfo_addressU_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->addressU, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_addressU_set) + +static bool js_cc_gfx_SamplerInfo_addressU_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->addressU, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->addressU, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_addressU_get) + +static bool js_cc_gfx_SamplerInfo_addressV_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->addressV, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_addressV_set) + +static bool js_cc_gfx_SamplerInfo_addressV_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->addressV, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->addressV, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_addressV_get) + +static bool js_cc_gfx_SamplerInfo_addressW_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->addressW, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_addressW_set) + +static bool js_cc_gfx_SamplerInfo_addressW_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->addressW, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->addressW, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_addressW_get) + +static bool js_cc_gfx_SamplerInfo_maxAnisotropy_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxAnisotropy, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_maxAnisotropy_set) + +static bool js_cc_gfx_SamplerInfo_maxAnisotropy_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxAnisotropy, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_maxAnisotropy_get) + +static bool js_cc_gfx_SamplerInfo_cmpFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cmpFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_cmpFunc_set) + +static bool js_cc_gfx_SamplerInfo_cmpFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cmpFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cmpFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_cmpFunc_get) + +static bool js_cc_gfx_SamplerInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + cc::gfx::SamplerInfo *arg2 = 0 ; + cc::gfx::SamplerInfo temp2 ; + cc::gfx::SamplerInfo *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(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::gfx::SamplerInfo *) &(arg1)->copy((cc::gfx::SamplerInfo 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_gfx_SamplerInfo_copy) + +static bool js_new_cc_gfx_SamplerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SamplerInfo *result; + result = (cc::gfx::SamplerInfo *)new cc::gfx::SamplerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SamplerInfo, __jsb_cc_gfx_SamplerInfo_class, js_delete_cc_gfx_SamplerInfo) + +static bool js_delete_cc_gfx_SamplerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SamplerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SamplerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("minFilter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minFilter), ctx); + } + + + json->getProperty("magFilter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->magFilter), ctx); + } + + + json->getProperty("mipFilter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipFilter), ctx); + } + + + json->getProperty("addressU", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->addressU), ctx); + } + + + json->getProperty("addressV", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->addressV), ctx); + } + + + json->getProperty("addressW", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->addressW), ctx); + } + + + json->getProperty("maxAnisotropy", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxAnisotropy), ctx); + } + + + json->getProperty("cmpFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cmpFunc), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SamplerInfo(se::Object* obj) { + auto* cls = se::Class::create("SamplerInfo", obj, nullptr, _SE(js_new_cc_gfx_SamplerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("minFilter", _SE(js_cc_gfx_SamplerInfo_minFilter_get), _SE(js_cc_gfx_SamplerInfo_minFilter_set)); + cls->defineProperty("magFilter", _SE(js_cc_gfx_SamplerInfo_magFilter_get), _SE(js_cc_gfx_SamplerInfo_magFilter_set)); + cls->defineProperty("mipFilter", _SE(js_cc_gfx_SamplerInfo_mipFilter_get), _SE(js_cc_gfx_SamplerInfo_mipFilter_set)); + cls->defineProperty("addressU", _SE(js_cc_gfx_SamplerInfo_addressU_get), _SE(js_cc_gfx_SamplerInfo_addressU_set)); + cls->defineProperty("addressV", _SE(js_cc_gfx_SamplerInfo_addressV_get), _SE(js_cc_gfx_SamplerInfo_addressV_set)); + cls->defineProperty("addressW", _SE(js_cc_gfx_SamplerInfo_addressW_get), _SE(js_cc_gfx_SamplerInfo_addressW_set)); + cls->defineProperty("maxAnisotropy", _SE(js_cc_gfx_SamplerInfo_maxAnisotropy_get), _SE(js_cc_gfx_SamplerInfo_maxAnisotropy_set)); + cls->defineProperty("cmpFunc", _SE(js_cc_gfx_SamplerInfo_cmpFunc_get), _SE(js_cc_gfx_SamplerInfo_cmpFunc_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SamplerInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SamplerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SamplerInfo_proto = cls->getProto(); + __jsb_cc_gfx_SamplerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Uniform_class = nullptr; +se::Object* __jsb_cc_gfx_Uniform_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Uniform) + +static bool js_cc_gfx_Uniform_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Uniform_name_set) + +static bool js_cc_gfx_Uniform_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Uniform_name_get) + +static bool js_cc_gfx_Uniform_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Uniform_type_set) + +static bool js_cc_gfx_Uniform_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Uniform_type_get) + +static bool js_cc_gfx_Uniform_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Uniform_count_set) + +static bool js_cc_gfx_Uniform_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Uniform_count_get) + +static bool js_cc_gfx_Uniform_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + cc::gfx::Uniform *arg2 = 0 ; + cc::gfx::Uniform temp2 ; + cc::gfx::Uniform *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(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::gfx::Uniform *) &(arg1)->copy((cc::gfx::Uniform 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_gfx_Uniform_copy) + +static bool js_new_cc_gfx_Uniform(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Uniform *result; + result = (cc::gfx::Uniform *)new cc::gfx::Uniform(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Uniform, __jsb_cc_gfx_Uniform_class, js_delete_cc_gfx_Uniform) + +static bool js_delete_cc_gfx_Uniform(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Uniform) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Uniform * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Uniform(se::Object* obj) { + auto* cls = se::Class::create("Uniform", obj, nullptr, _SE(js_new_cc_gfx_Uniform)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_Uniform_name_get), _SE(js_cc_gfx_Uniform_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_Uniform_type_get), _SE(js_cc_gfx_Uniform_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_Uniform_count_get), _SE(js_cc_gfx_Uniform_count_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Uniform_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Uniform)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Uniform_proto = cls->getProto(); + __jsb_cc_gfx_Uniform_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformBlock_class = nullptr; +se::Object* __jsb_cc_gfx_UniformBlock_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformBlock) + +static bool js_cc_gfx_UniformBlock_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_set_set) + +static bool js_cc_gfx_UniformBlock_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_set_get) + +static bool js_cc_gfx_UniformBlock_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_binding_set) + +static bool js_cc_gfx_UniformBlock_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_binding_get) + +static bool js_cc_gfx_UniformBlock_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_name_set) + +static bool js_cc_gfx_UniformBlock_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_name_get) + +static bool js_cc_gfx_UniformBlock_members_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->members, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_members_set) + +static bool js_cc_gfx_UniformBlock_members_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->members, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->members, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_members_get) + +static bool js_cc_gfx_UniformBlock_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_count_set) + +static bool js_cc_gfx_UniformBlock_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_count_get) + +static bool js_cc_gfx_UniformBlock_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_flattened_set) + +static bool js_cc_gfx_UniformBlock_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_flattened_get) + +static bool js_cc_gfx_UniformBlock_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + cc::gfx::UniformBlock *arg2 = 0 ; + cc::gfx::UniformBlock temp2 ; + cc::gfx::UniformBlock *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(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::gfx::UniformBlock *) &(arg1)->copy((cc::gfx::UniformBlock 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_gfx_UniformBlock_copy) + +static bool js_new_cc_gfx_UniformBlock(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformBlock *result; + result = (cc::gfx::UniformBlock *)new cc::gfx::UniformBlock(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformBlock, __jsb_cc_gfx_UniformBlock_class, js_delete_cc_gfx_UniformBlock) + +static bool js_delete_cc_gfx_UniformBlock(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformBlock) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformBlock * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("members", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->members), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformBlock(se::Object* obj) { + auto* cls = se::Class::create("UniformBlock", obj, nullptr, _SE(js_new_cc_gfx_UniformBlock)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformBlock_set_get), _SE(js_cc_gfx_UniformBlock_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformBlock_binding_get), _SE(js_cc_gfx_UniformBlock_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformBlock_name_get), _SE(js_cc_gfx_UniformBlock_name_set)); + cls->defineProperty("members", _SE(js_cc_gfx_UniformBlock_members_get), _SE(js_cc_gfx_UniformBlock_members_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformBlock_count_get), _SE(js_cc_gfx_UniformBlock_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformBlock_flattened_get), _SE(js_cc_gfx_UniformBlock_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformBlock_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformBlock)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformBlock_proto = cls->getProto(); + __jsb_cc_gfx_UniformBlock_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformSamplerTexture_class = nullptr; +se::Object* __jsb_cc_gfx_UniformSamplerTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformSamplerTexture) + +static bool js_cc_gfx_UniformSamplerTexture_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_set_set) + +static bool js_cc_gfx_UniformSamplerTexture_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_set_get) + +static bool js_cc_gfx_UniformSamplerTexture_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_binding_set) + +static bool js_cc_gfx_UniformSamplerTexture_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_binding_get) + +static bool js_cc_gfx_UniformSamplerTexture_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_name_set) + +static bool js_cc_gfx_UniformSamplerTexture_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_name_get) + +static bool js_cc_gfx_UniformSamplerTexture_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_type_set) + +static bool js_cc_gfx_UniformSamplerTexture_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_type_get) + +static bool js_cc_gfx_UniformSamplerTexture_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_count_set) + +static bool js_cc_gfx_UniformSamplerTexture_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_count_get) + +static bool js_cc_gfx_UniformSamplerTexture_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_flattened_set) + +static bool js_cc_gfx_UniformSamplerTexture_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_flattened_get) + +static bool js_cc_gfx_UniformSamplerTexture_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + cc::gfx::UniformSamplerTexture *arg2 = 0 ; + cc::gfx::UniformSamplerTexture temp2 ; + cc::gfx::UniformSamplerTexture *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(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::gfx::UniformSamplerTexture *) &(arg1)->copy((cc::gfx::UniformSamplerTexture 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_gfx_UniformSamplerTexture_copy) + +static bool js_new_cc_gfx_UniformSamplerTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformSamplerTexture *result; + result = (cc::gfx::UniformSamplerTexture *)new cc::gfx::UniformSamplerTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformSamplerTexture, __jsb_cc_gfx_UniformSamplerTexture_class, js_delete_cc_gfx_UniformSamplerTexture) + +static bool js_delete_cc_gfx_UniformSamplerTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformSamplerTexture) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSamplerTexture * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformSamplerTexture(se::Object* obj) { + auto* cls = se::Class::create("UniformSamplerTexture", obj, nullptr, _SE(js_new_cc_gfx_UniformSamplerTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformSamplerTexture_set_get), _SE(js_cc_gfx_UniformSamplerTexture_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformSamplerTexture_binding_get), _SE(js_cc_gfx_UniformSamplerTexture_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformSamplerTexture_name_get), _SE(js_cc_gfx_UniformSamplerTexture_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_UniformSamplerTexture_type_get), _SE(js_cc_gfx_UniformSamplerTexture_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformSamplerTexture_count_get), _SE(js_cc_gfx_UniformSamplerTexture_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformSamplerTexture_flattened_get), _SE(js_cc_gfx_UniformSamplerTexture_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformSamplerTexture_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformSamplerTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformSamplerTexture_proto = cls->getProto(); + __jsb_cc_gfx_UniformSamplerTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformSampler_class = nullptr; +se::Object* __jsb_cc_gfx_UniformSampler_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformSampler) + +static bool js_cc_gfx_UniformSampler_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_set_set) + +static bool js_cc_gfx_UniformSampler_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_set_get) + +static bool js_cc_gfx_UniformSampler_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_binding_set) + +static bool js_cc_gfx_UniformSampler_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_binding_get) + +static bool js_cc_gfx_UniformSampler_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_name_set) + +static bool js_cc_gfx_UniformSampler_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_name_get) + +static bool js_cc_gfx_UniformSampler_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_count_set) + +static bool js_cc_gfx_UniformSampler_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_count_get) + +static bool js_cc_gfx_UniformSampler_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_flattened_set) + +static bool js_cc_gfx_UniformSampler_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_flattened_get) + +static bool js_cc_gfx_UniformSampler_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + cc::gfx::UniformSampler *arg2 = 0 ; + cc::gfx::UniformSampler temp2 ; + cc::gfx::UniformSampler *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(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::gfx::UniformSampler *) &(arg1)->copy((cc::gfx::UniformSampler 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_gfx_UniformSampler_copy) + +static bool js_new_cc_gfx_UniformSampler(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformSampler *result; + result = (cc::gfx::UniformSampler *)new cc::gfx::UniformSampler(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformSampler, __jsb_cc_gfx_UniformSampler_class, js_delete_cc_gfx_UniformSampler) + +static bool js_delete_cc_gfx_UniformSampler(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformSampler) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSampler * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformSampler(se::Object* obj) { + auto* cls = se::Class::create("UniformSampler", obj, nullptr, _SE(js_new_cc_gfx_UniformSampler)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformSampler_set_get), _SE(js_cc_gfx_UniformSampler_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformSampler_binding_get), _SE(js_cc_gfx_UniformSampler_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformSampler_name_get), _SE(js_cc_gfx_UniformSampler_name_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformSampler_count_get), _SE(js_cc_gfx_UniformSampler_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformSampler_flattened_get), _SE(js_cc_gfx_UniformSampler_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformSampler_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformSampler)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformSampler_proto = cls->getProto(); + __jsb_cc_gfx_UniformSampler_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformTexture_class = nullptr; +se::Object* __jsb_cc_gfx_UniformTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformTexture) + +static bool js_cc_gfx_UniformTexture_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_set_set) + +static bool js_cc_gfx_UniformTexture_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_set_get) + +static bool js_cc_gfx_UniformTexture_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_binding_set) + +static bool js_cc_gfx_UniformTexture_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_binding_get) + +static bool js_cc_gfx_UniformTexture_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_name_set) + +static bool js_cc_gfx_UniformTexture_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_name_get) + +static bool js_cc_gfx_UniformTexture_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_type_set) + +static bool js_cc_gfx_UniformTexture_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_type_get) + +static bool js_cc_gfx_UniformTexture_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_count_set) + +static bool js_cc_gfx_UniformTexture_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_count_get) + +static bool js_cc_gfx_UniformTexture_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_flattened_set) + +static bool js_cc_gfx_UniformTexture_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_flattened_get) + +static bool js_cc_gfx_UniformTexture_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + cc::gfx::UniformTexture *arg2 = 0 ; + cc::gfx::UniformTexture temp2 ; + cc::gfx::UniformTexture *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(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::gfx::UniformTexture *) &(arg1)->copy((cc::gfx::UniformTexture 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_gfx_UniformTexture_copy) + +static bool js_new_cc_gfx_UniformTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformTexture *result; + result = (cc::gfx::UniformTexture *)new cc::gfx::UniformTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformTexture, __jsb_cc_gfx_UniformTexture_class, js_delete_cc_gfx_UniformTexture) + +static bool js_delete_cc_gfx_UniformTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformTexture) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformTexture * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformTexture(se::Object* obj) { + auto* cls = se::Class::create("UniformTexture", obj, nullptr, _SE(js_new_cc_gfx_UniformTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformTexture_set_get), _SE(js_cc_gfx_UniformTexture_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformTexture_binding_get), _SE(js_cc_gfx_UniformTexture_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformTexture_name_get), _SE(js_cc_gfx_UniformTexture_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_UniformTexture_type_get), _SE(js_cc_gfx_UniformTexture_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformTexture_count_get), _SE(js_cc_gfx_UniformTexture_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformTexture_flattened_get), _SE(js_cc_gfx_UniformTexture_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformTexture_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformTexture_proto = cls->getProto(); + __jsb_cc_gfx_UniformTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformStorageImage_class = nullptr; +se::Object* __jsb_cc_gfx_UniformStorageImage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageImage) + +static bool js_cc_gfx_UniformStorageImage_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_set_set) + +static bool js_cc_gfx_UniformStorageImage_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_set_get) + +static bool js_cc_gfx_UniformStorageImage_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_binding_set) + +static bool js_cc_gfx_UniformStorageImage_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_binding_get) + +static bool js_cc_gfx_UniformStorageImage_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_name_set) + +static bool js_cc_gfx_UniformStorageImage_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_name_get) + +static bool js_cc_gfx_UniformStorageImage_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_type_set) + +static bool js_cc_gfx_UniformStorageImage_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_type_get) + +static bool js_cc_gfx_UniformStorageImage_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_count_set) + +static bool js_cc_gfx_UniformStorageImage_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_count_get) + +static bool js_cc_gfx_UniformStorageImage_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_memoryAccess_set) + +static bool js_cc_gfx_UniformStorageImage_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_memoryAccess_get) + +static bool js_cc_gfx_UniformStorageImage_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_flattened_set) + +static bool js_cc_gfx_UniformStorageImage_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_flattened_get) + +static bool js_cc_gfx_UniformStorageImage_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + cc::gfx::UniformStorageImage *arg2 = 0 ; + cc::gfx::UniformStorageImage temp2 ; + cc::gfx::UniformStorageImage *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(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::gfx::UniformStorageImage *) &(arg1)->copy((cc::gfx::UniformStorageImage 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_gfx_UniformStorageImage_copy) + +static bool js_new_cc_gfx_UniformStorageImage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformStorageImage *result; + result = (cc::gfx::UniformStorageImage *)new cc::gfx::UniformStorageImage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformStorageImage, __jsb_cc_gfx_UniformStorageImage_class, js_delete_cc_gfx_UniformStorageImage) + +static bool js_delete_cc_gfx_UniformStorageImage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageImage) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageImage * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformStorageImage(se::Object* obj) { + auto* cls = se::Class::create("UniformStorageImage", obj, nullptr, _SE(js_new_cc_gfx_UniformStorageImage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformStorageImage_set_get), _SE(js_cc_gfx_UniformStorageImage_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformStorageImage_binding_get), _SE(js_cc_gfx_UniformStorageImage_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformStorageImage_name_get), _SE(js_cc_gfx_UniformStorageImage_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_UniformStorageImage_type_get), _SE(js_cc_gfx_UniformStorageImage_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformStorageImage_count_get), _SE(js_cc_gfx_UniformStorageImage_count_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_gfx_UniformStorageImage_memoryAccess_get), _SE(js_cc_gfx_UniformStorageImage_memoryAccess_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformStorageImage_flattened_get), _SE(js_cc_gfx_UniformStorageImage_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformStorageImage_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformStorageImage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformStorageImage_proto = cls->getProto(); + __jsb_cc_gfx_UniformStorageImage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformStorageBuffer_class = nullptr; +se::Object* __jsb_cc_gfx_UniformStorageBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageBuffer) + +static bool js_cc_gfx_UniformStorageBuffer_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_set_set) + +static bool js_cc_gfx_UniformStorageBuffer_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_set_get) + +static bool js_cc_gfx_UniformStorageBuffer_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_binding_set) + +static bool js_cc_gfx_UniformStorageBuffer_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_binding_get) + +static bool js_cc_gfx_UniformStorageBuffer_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_name_set) + +static bool js_cc_gfx_UniformStorageBuffer_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_name_get) + +static bool js_cc_gfx_UniformStorageBuffer_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_count_set) + +static bool js_cc_gfx_UniformStorageBuffer_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_count_get) + +static bool js_cc_gfx_UniformStorageBuffer_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_memoryAccess_set) + +static bool js_cc_gfx_UniformStorageBuffer_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_memoryAccess_get) + +static bool js_cc_gfx_UniformStorageBuffer_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_flattened_set) + +static bool js_cc_gfx_UniformStorageBuffer_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_flattened_get) + +static bool js_cc_gfx_UniformStorageBuffer_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + cc::gfx::UniformStorageBuffer *arg2 = 0 ; + cc::gfx::UniformStorageBuffer temp2 ; + cc::gfx::UniformStorageBuffer *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(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::gfx::UniformStorageBuffer *) &(arg1)->copy((cc::gfx::UniformStorageBuffer 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_gfx_UniformStorageBuffer_copy) + +static bool js_new_cc_gfx_UniformStorageBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformStorageBuffer *result; + result = (cc::gfx::UniformStorageBuffer *)new cc::gfx::UniformStorageBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformStorageBuffer, __jsb_cc_gfx_UniformStorageBuffer_class, js_delete_cc_gfx_UniformStorageBuffer) + +static bool js_delete_cc_gfx_UniformStorageBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageBuffer) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageBuffer * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformStorageBuffer(se::Object* obj) { + auto* cls = se::Class::create("UniformStorageBuffer", obj, nullptr, _SE(js_new_cc_gfx_UniformStorageBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformStorageBuffer_set_get), _SE(js_cc_gfx_UniformStorageBuffer_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformStorageBuffer_binding_get), _SE(js_cc_gfx_UniformStorageBuffer_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformStorageBuffer_name_get), _SE(js_cc_gfx_UniformStorageBuffer_name_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformStorageBuffer_count_get), _SE(js_cc_gfx_UniformStorageBuffer_count_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_gfx_UniformStorageBuffer_memoryAccess_get), _SE(js_cc_gfx_UniformStorageBuffer_memoryAccess_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformStorageBuffer_flattened_get), _SE(js_cc_gfx_UniformStorageBuffer_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformStorageBuffer_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformStorageBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformStorageBuffer_proto = cls->getProto(); + __jsb_cc_gfx_UniformStorageBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformInputAttachment_class = nullptr; +se::Object* __jsb_cc_gfx_UniformInputAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformInputAttachment) + +static bool js_cc_gfx_UniformInputAttachment_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_set_set) + +static bool js_cc_gfx_UniformInputAttachment_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_set_get) + +static bool js_cc_gfx_UniformInputAttachment_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_binding_set) + +static bool js_cc_gfx_UniformInputAttachment_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_binding_get) + +static bool js_cc_gfx_UniformInputAttachment_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_name_set) + +static bool js_cc_gfx_UniformInputAttachment_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_name_get) + +static bool js_cc_gfx_UniformInputAttachment_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_count_set) + +static bool js_cc_gfx_UniformInputAttachment_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_count_get) + +static bool js_cc_gfx_UniformInputAttachment_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_flattened_set) + +static bool js_cc_gfx_UniformInputAttachment_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_flattened_get) + +static bool js_cc_gfx_UniformInputAttachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + cc::gfx::UniformInputAttachment *arg2 = 0 ; + cc::gfx::UniformInputAttachment temp2 ; + cc::gfx::UniformInputAttachment *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(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::gfx::UniformInputAttachment *) &(arg1)->copy((cc::gfx::UniformInputAttachment 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_gfx_UniformInputAttachment_copy) + +static bool js_new_cc_gfx_UniformInputAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformInputAttachment *result; + result = (cc::gfx::UniformInputAttachment *)new cc::gfx::UniformInputAttachment(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformInputAttachment, __jsb_cc_gfx_UniformInputAttachment_class, js_delete_cc_gfx_UniformInputAttachment) + +static bool js_delete_cc_gfx_UniformInputAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformInputAttachment) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformInputAttachment * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformInputAttachment(se::Object* obj) { + auto* cls = se::Class::create("UniformInputAttachment", obj, nullptr, _SE(js_new_cc_gfx_UniformInputAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformInputAttachment_set_get), _SE(js_cc_gfx_UniformInputAttachment_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformInputAttachment_binding_get), _SE(js_cc_gfx_UniformInputAttachment_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformInputAttachment_name_get), _SE(js_cc_gfx_UniformInputAttachment_name_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformInputAttachment_count_get), _SE(js_cc_gfx_UniformInputAttachment_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformInputAttachment_flattened_get), _SE(js_cc_gfx_UniformInputAttachment_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformInputAttachment_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformInputAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformInputAttachment_proto = cls->getProto(); + __jsb_cc_gfx_UniformInputAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ShaderStage_class = nullptr; +se::Object* __jsb_cc_gfx_ShaderStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ShaderStage) + +static bool js_cc_gfx_ShaderStage_stage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderStage_stage_set) + +static bool js_cc_gfx_ShaderStage_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderStage_stage_get) + +static bool js_cc_gfx_ShaderStage_source_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->source, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderStage_source_set) + +static bool js_cc_gfx_ShaderStage_source_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->source, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->source, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderStage_source_get) + +static bool js_cc_gfx_ShaderStage_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + cc::gfx::ShaderStage *arg2 = 0 ; + cc::gfx::ShaderStage temp2 ; + cc::gfx::ShaderStage *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(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::gfx::ShaderStage *) &(arg1)->copy((cc::gfx::ShaderStage 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_gfx_ShaderStage_copy) + +static bool js_new_cc_gfx_ShaderStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ShaderStage *result; + result = (cc::gfx::ShaderStage *)new cc::gfx::ShaderStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ShaderStage, __jsb_cc_gfx_ShaderStage_class, js_delete_cc_gfx_ShaderStage) + +static bool js_delete_cc_gfx_ShaderStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ShaderStage) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderStage * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("stage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stage), ctx); + } + + + json->getProperty("source", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->source), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ShaderStage(se::Object* obj) { + auto* cls = se::Class::create("ShaderStage", obj, nullptr, _SE(js_new_cc_gfx_ShaderStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("stage", _SE(js_cc_gfx_ShaderStage_stage_get), _SE(js_cc_gfx_ShaderStage_stage_set)); + cls->defineProperty("source", _SE(js_cc_gfx_ShaderStage_source_get), _SE(js_cc_gfx_ShaderStage_source_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_ShaderStage_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ShaderStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ShaderStage_proto = cls->getProto(); + __jsb_cc_gfx_ShaderStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Attribute_class = nullptr; +se::Object* __jsb_cc_gfx_Attribute_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Attribute) + +static bool js_cc_gfx_Attribute_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_name_set) + +static bool js_cc_gfx_Attribute_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_name_get) + +static bool js_cc_gfx_Attribute_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_format_set) + +static bool js_cc_gfx_Attribute_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_format_get) + +static bool js_cc_gfx_Attribute_isNormalized_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isNormalized); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_isNormalized_set) + +static bool js_cc_gfx_Attribute_isNormalized_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isNormalized, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_isNormalized_get) + +static bool js_cc_gfx_Attribute_stream_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stream, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_stream_set) + +static bool js_cc_gfx_Attribute_stream_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stream, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_stream_get) + +static bool js_cc_gfx_Attribute_isInstanced_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isInstanced); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_isInstanced_set) + +static bool js_cc_gfx_Attribute_isInstanced_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isInstanced, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_isInstanced_get) + +static bool js_cc_gfx_Attribute_location_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->location, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_location_set) + +static bool js_cc_gfx_Attribute_location_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->location, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_location_get) + +static bool js_cc_gfx_Attribute_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + cc::gfx::Attribute *arg2 = 0 ; + cc::gfx::Attribute temp2 ; + cc::gfx::Attribute *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(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::gfx::Attribute *) &(arg1)->copy((cc::gfx::Attribute 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_gfx_Attribute_copy) + +static bool js_new_cc_gfx_Attribute(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Attribute *result; + result = (cc::gfx::Attribute *)new cc::gfx::Attribute(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Attribute, __jsb_cc_gfx_Attribute_class, js_delete_cc_gfx_Attribute) + +static bool js_delete_cc_gfx_Attribute(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Attribute) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Attribute * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("isNormalized", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isNormalized), ctx); + } + + + json->getProperty("stream", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stream), ctx); + } + + + json->getProperty("isInstanced", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isInstanced), ctx); + } + + + json->getProperty("location", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->location), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Attribute(se::Object* obj) { + auto* cls = se::Class::create("Attribute", obj, nullptr, _SE(js_new_cc_gfx_Attribute)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_Attribute_name_get), _SE(js_cc_gfx_Attribute_name_set)); + cls->defineProperty("format", _SE(js_cc_gfx_Attribute_format_get), _SE(js_cc_gfx_Attribute_format_set)); + cls->defineProperty("isNormalized", _SE(js_cc_gfx_Attribute_isNormalized_get), _SE(js_cc_gfx_Attribute_isNormalized_set)); + cls->defineProperty("stream", _SE(js_cc_gfx_Attribute_stream_get), _SE(js_cc_gfx_Attribute_stream_set)); + cls->defineProperty("isInstanced", _SE(js_cc_gfx_Attribute_isInstanced_get), _SE(js_cc_gfx_Attribute_isInstanced_set)); + cls->defineProperty("location", _SE(js_cc_gfx_Attribute_location_get), _SE(js_cc_gfx_Attribute_location_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Attribute_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Attribute)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Attribute_proto = cls->getProto(); + __jsb_cc_gfx_Attribute_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ShaderInfo_class = nullptr; +se::Object* __jsb_cc_gfx_ShaderInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ShaderInfo) + +static bool js_cc_gfx_ShaderInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_name_set) + +static bool js_cc_gfx_ShaderInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_name_get) + +static bool js_cc_gfx_ShaderInfo_stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_stages_set) + +static bool js_cc_gfx_ShaderInfo_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_stages_get) + +static bool js_cc_gfx_ShaderInfo_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_attributes_set) + +static bool js_cc_gfx_ShaderInfo_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_attributes_get) + +static bool js_cc_gfx_ShaderInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_blocks_set) + +static bool js_cc_gfx_ShaderInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_blocks_get) + +static bool js_cc_gfx_ShaderInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_buffers_set) + +static bool js_cc_gfx_ShaderInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_buffers_get) + +static bool js_cc_gfx_ShaderInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_samplerTextures_set) + +static bool js_cc_gfx_ShaderInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_samplerTextures_get) + +static bool js_cc_gfx_ShaderInfo_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_samplers_set) + +static bool js_cc_gfx_ShaderInfo_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_samplers_get) + +static bool js_cc_gfx_ShaderInfo_textures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_textures_set) + +static bool js_cc_gfx_ShaderInfo_textures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_textures_get) + +static bool js_cc_gfx_ShaderInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_images_set) + +static bool js_cc_gfx_ShaderInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_images_get) + +static bool js_cc_gfx_ShaderInfo_subpassInputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassInputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_subpassInputs_set) + +static bool js_cc_gfx_ShaderInfo_subpassInputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassInputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpassInputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_subpassInputs_get) + +static bool js_cc_gfx_ShaderInfo_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_hash_set) + +static bool js_cc_gfx_ShaderInfo_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hash, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->hash, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_hash_get) + +static bool js_cc_gfx_ShaderInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + cc::gfx::ShaderInfo *arg2 = 0 ; + cc::gfx::ShaderInfo temp2 ; + cc::gfx::ShaderInfo *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(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::gfx::ShaderInfo *) &(arg1)->copy((cc::gfx::ShaderInfo 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_gfx_ShaderInfo_copy) + +static bool js_new_cc_gfx_ShaderInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ShaderInfo *result; + result = (cc::gfx::ShaderInfo *)new cc::gfx::ShaderInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ShaderInfo, __jsb_cc_gfx_ShaderInfo_class, js_delete_cc_gfx_ShaderInfo) + +static bool js_delete_cc_gfx_ShaderInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ShaderInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("stages", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stages), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("textures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textures), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + json->getProperty("subpassInputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassInputs), ctx); + } + + + json->getProperty("hash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hash), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ShaderInfo(se::Object* obj) { + auto* cls = se::Class::create("ShaderInfo", obj, nullptr, _SE(js_new_cc_gfx_ShaderInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_ShaderInfo_name_get), _SE(js_cc_gfx_ShaderInfo_name_set)); + cls->defineProperty("stages", _SE(js_cc_gfx_ShaderInfo_stages_get), _SE(js_cc_gfx_ShaderInfo_stages_set)); + cls->defineProperty("attributes", _SE(js_cc_gfx_ShaderInfo_attributes_get), _SE(js_cc_gfx_ShaderInfo_attributes_set)); + cls->defineProperty("blocks", _SE(js_cc_gfx_ShaderInfo_blocks_get), _SE(js_cc_gfx_ShaderInfo_blocks_set)); + cls->defineProperty("buffers", _SE(js_cc_gfx_ShaderInfo_buffers_get), _SE(js_cc_gfx_ShaderInfo_buffers_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_gfx_ShaderInfo_samplerTextures_get), _SE(js_cc_gfx_ShaderInfo_samplerTextures_set)); + cls->defineProperty("samplers", _SE(js_cc_gfx_ShaderInfo_samplers_get), _SE(js_cc_gfx_ShaderInfo_samplers_set)); + cls->defineProperty("textures", _SE(js_cc_gfx_ShaderInfo_textures_get), _SE(js_cc_gfx_ShaderInfo_textures_set)); + cls->defineProperty("images", _SE(js_cc_gfx_ShaderInfo_images_get), _SE(js_cc_gfx_ShaderInfo_images_set)); + cls->defineProperty("subpassInputs", _SE(js_cc_gfx_ShaderInfo_subpassInputs_get), _SE(js_cc_gfx_ShaderInfo_subpassInputs_set)); + cls->defineProperty("hash", _SE(js_cc_gfx_ShaderInfo_hash_get), _SE(js_cc_gfx_ShaderInfo_hash_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_ShaderInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ShaderInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ShaderInfo_proto = cls->getProto(); + __jsb_cc_gfx_ShaderInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_InputAssemblerInfo_class = nullptr; +se::Object* __jsb_cc_gfx_InputAssemblerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_InputAssemblerInfo) + +static bool js_cc_gfx_InputAssemblerInfo_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_attributes_set) + +static bool js_cc_gfx_InputAssemblerInfo_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_attributes_get) + +static bool js_cc_gfx_InputAssemblerInfo_vertexBuffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexBuffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_vertexBuffers_set) + +static bool js_cc_gfx_InputAssemblerInfo_vertexBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexBuffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexBuffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_vertexBuffers_get) + +static bool js_cc_gfx_InputAssemblerInfo_indexBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexBuffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_indexBuffer_set) + +static bool js_cc_gfx_InputAssemblerInfo_indexBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexBuffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexBuffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_indexBuffer_get) + +static bool js_cc_gfx_InputAssemblerInfo_indirectBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indirectBuffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_indirectBuffer_set) + +static bool js_cc_gfx_InputAssemblerInfo_indirectBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indirectBuffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indirectBuffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_indirectBuffer_get) + +static bool js_cc_gfx_InputAssemblerInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + cc::gfx::InputAssemblerInfo *arg2 = 0 ; + cc::gfx::InputAssemblerInfo temp2 ; + cc::gfx::InputAssemblerInfo *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(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::gfx::InputAssemblerInfo *) &(arg1)->copy((cc::gfx::InputAssemblerInfo 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_gfx_InputAssemblerInfo_copy) + +static bool js_new_cc_gfx_InputAssemblerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::InputAssemblerInfo *result; + result = (cc::gfx::InputAssemblerInfo *)new cc::gfx::InputAssemblerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_InputAssemblerInfo, __jsb_cc_gfx_InputAssemblerInfo_class, js_delete_cc_gfx_InputAssemblerInfo) + +static bool js_delete_cc_gfx_InputAssemblerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_InputAssemblerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputAssemblerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("vertexBuffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexBuffers), ctx); + } + + + json->getProperty("indexBuffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexBuffer), ctx); + } + + + json->getProperty("indirectBuffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indirectBuffer), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_InputAssemblerInfo(se::Object* obj) { + auto* cls = se::Class::create("InputAssemblerInfo", obj, nullptr, _SE(js_new_cc_gfx_InputAssemblerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attributes", _SE(js_cc_gfx_InputAssemblerInfo_attributes_get), _SE(js_cc_gfx_InputAssemblerInfo_attributes_set)); + cls->defineProperty("vertexBuffers", _SE(js_cc_gfx_InputAssemblerInfo_vertexBuffers_get), _SE(js_cc_gfx_InputAssemblerInfo_vertexBuffers_set)); + cls->defineProperty("indexBuffer", _SE(js_cc_gfx_InputAssemblerInfo_indexBuffer_get), _SE(js_cc_gfx_InputAssemblerInfo_indexBuffer_set)); + cls->defineProperty("indirectBuffer", _SE(js_cc_gfx_InputAssemblerInfo_indirectBuffer_get), _SE(js_cc_gfx_InputAssemblerInfo_indirectBuffer_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_InputAssemblerInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_InputAssemblerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_InputAssemblerInfo_proto = cls->getProto(); + __jsb_cc_gfx_InputAssemblerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ColorAttachment_class = nullptr; +se::Object* __jsb_cc_gfx_ColorAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ColorAttachment) + +static bool js_cc_gfx_ColorAttachment_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_format_set) + +static bool js_cc_gfx_ColorAttachment_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_format_get) + +static bool js_cc_gfx_ColorAttachment_sampleCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampleCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_sampleCount_set) + +static bool js_cc_gfx_ColorAttachment_sampleCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampleCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampleCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_sampleCount_get) + +static bool js_cc_gfx_ColorAttachment_loadOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->loadOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_loadOp_set) + +static bool js_cc_gfx_ColorAttachment_loadOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->loadOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->loadOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_loadOp_get) + +static bool js_cc_gfx_ColorAttachment_storeOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storeOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_storeOp_set) + +static bool js_cc_gfx_ColorAttachment_storeOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storeOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storeOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_storeOp_get) + +static bool js_cc_gfx_ColorAttachment_barrier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->barrier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_barrier_set) + +static bool js_cc_gfx_ColorAttachment_barrier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->barrier, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->barrier, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_barrier_get) + +static bool js_cc_gfx_ColorAttachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + cc::gfx::ColorAttachment *arg2 = 0 ; + cc::gfx::ColorAttachment temp2 ; + cc::gfx::ColorAttachment *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(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::gfx::ColorAttachment *) &(arg1)->copy((cc::gfx::ColorAttachment 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_gfx_ColorAttachment_copy) + +static bool js_new_cc_gfx_ColorAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ColorAttachment *result; + result = (cc::gfx::ColorAttachment *)new cc::gfx::ColorAttachment(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ColorAttachment, __jsb_cc_gfx_ColorAttachment_class, js_delete_cc_gfx_ColorAttachment) + +static bool js_delete_cc_gfx_ColorAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ColorAttachment) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ColorAttachment * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("sampleCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampleCount), ctx); + } + + + json->getProperty("loadOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->loadOp), ctx); + } + + + json->getProperty("storeOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->storeOp), ctx); + } + + + json->getProperty("barrier", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->barrier), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ColorAttachment(se::Object* obj) { + auto* cls = se::Class::create("ColorAttachment", obj, nullptr, _SE(js_new_cc_gfx_ColorAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("format", _SE(js_cc_gfx_ColorAttachment_format_get), _SE(js_cc_gfx_ColorAttachment_format_set)); + cls->defineProperty("sampleCount", _SE(js_cc_gfx_ColorAttachment_sampleCount_get), _SE(js_cc_gfx_ColorAttachment_sampleCount_set)); + cls->defineProperty("loadOp", _SE(js_cc_gfx_ColorAttachment_loadOp_get), _SE(js_cc_gfx_ColorAttachment_loadOp_set)); + cls->defineProperty("storeOp", _SE(js_cc_gfx_ColorAttachment_storeOp_get), _SE(js_cc_gfx_ColorAttachment_storeOp_set)); + cls->defineProperty("barrier", _SE(js_cc_gfx_ColorAttachment_barrier_get), _SE(js_cc_gfx_ColorAttachment_barrier_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_ColorAttachment_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ColorAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ColorAttachment_proto = cls->getProto(); + __jsb_cc_gfx_ColorAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DepthStencilAttachment_class = nullptr; +se::Object* __jsb_cc_gfx_DepthStencilAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilAttachment) + +static bool js_cc_gfx_DepthStencilAttachment_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_format_set) + +static bool js_cc_gfx_DepthStencilAttachment_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_format_get) + +static bool js_cc_gfx_DepthStencilAttachment_sampleCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampleCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_sampleCount_set) + +static bool js_cc_gfx_DepthStencilAttachment_sampleCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampleCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampleCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_sampleCount_get) + +static bool js_cc_gfx_DepthStencilAttachment_depthLoadOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthLoadOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_depthLoadOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_depthLoadOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthLoadOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthLoadOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_depthLoadOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_depthStoreOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStoreOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_depthStoreOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_depthStoreOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStoreOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStoreOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_depthStoreOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_stencilLoadOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilLoadOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_stencilLoadOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilLoadOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilLoadOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_stencilStoreOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilStoreOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_stencilStoreOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilStoreOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilStoreOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_barrier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->barrier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_barrier_set) + +static bool js_cc_gfx_DepthStencilAttachment_barrier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->barrier, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->barrier, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_barrier_get) + +static bool js_cc_gfx_DepthStencilAttachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + cc::gfx::DepthStencilAttachment *arg2 = 0 ; + cc::gfx::DepthStencilAttachment temp2 ; + cc::gfx::DepthStencilAttachment *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(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::gfx::DepthStencilAttachment *) &(arg1)->copy((cc::gfx::DepthStencilAttachment 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_gfx_DepthStencilAttachment_copy) + +static bool js_new_cc_gfx_DepthStencilAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DepthStencilAttachment *result; + result = (cc::gfx::DepthStencilAttachment *)new cc::gfx::DepthStencilAttachment(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DepthStencilAttachment, __jsb_cc_gfx_DepthStencilAttachment_class, js_delete_cc_gfx_DepthStencilAttachment) + +static bool js_delete_cc_gfx_DepthStencilAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilAttachment) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilAttachment * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("sampleCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampleCount), ctx); + } + + + json->getProperty("depthLoadOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthLoadOp), ctx); + } + + + json->getProperty("depthStoreOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStoreOp), ctx); + } + + + json->getProperty("stencilLoadOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilLoadOp), ctx); + } + + + json->getProperty("stencilStoreOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilStoreOp), ctx); + } + + + json->getProperty("barrier", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->barrier), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DepthStencilAttachment(se::Object* obj) { + auto* cls = se::Class::create("DepthStencilAttachment", obj, nullptr, _SE(js_new_cc_gfx_DepthStencilAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("format", _SE(js_cc_gfx_DepthStencilAttachment_format_get), _SE(js_cc_gfx_DepthStencilAttachment_format_set)); + cls->defineProperty("sampleCount", _SE(js_cc_gfx_DepthStencilAttachment_sampleCount_get), _SE(js_cc_gfx_DepthStencilAttachment_sampleCount_set)); + cls->defineProperty("depthLoadOp", _SE(js_cc_gfx_DepthStencilAttachment_depthLoadOp_get), _SE(js_cc_gfx_DepthStencilAttachment_depthLoadOp_set)); + cls->defineProperty("depthStoreOp", _SE(js_cc_gfx_DepthStencilAttachment_depthStoreOp_get), _SE(js_cc_gfx_DepthStencilAttachment_depthStoreOp_set)); + cls->defineProperty("stencilLoadOp", _SE(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_get), _SE(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_set)); + cls->defineProperty("stencilStoreOp", _SE(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_get), _SE(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_set)); + cls->defineProperty("barrier", _SE(js_cc_gfx_DepthStencilAttachment_barrier_get), _SE(js_cc_gfx_DepthStencilAttachment_barrier_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DepthStencilAttachment_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DepthStencilAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DepthStencilAttachment_proto = cls->getProto(); + __jsb_cc_gfx_DepthStencilAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SubpassInfo_class = nullptr; +se::Object* __jsb_cc_gfx_SubpassInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SubpassInfo) + +static bool js_cc_gfx_SubpassInfo_inputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_inputs_set) + +static bool js_cc_gfx_SubpassInfo_inputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->inputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_inputs_get) + +static bool js_cc_gfx_SubpassInfo_colors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_colors_set) + +static bool js_cc_gfx_SubpassInfo_colors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_colors_get) + +static bool js_cc_gfx_SubpassInfo_resolves_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->resolves, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_resolves_set) + +static bool js_cc_gfx_SubpassInfo_resolves_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->resolves, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->resolves, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_resolves_get) + +static bool js_cc_gfx_SubpassInfo_preserves_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->preserves, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_preserves_set) + +static bool js_cc_gfx_SubpassInfo_preserves_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->preserves, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->preserves, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_preserves_get) + +static bool js_cc_gfx_SubpassInfo_depthStencil_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencil, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_depthStencil_set) + +static bool js_cc_gfx_SubpassInfo_depthStencil_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencil, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_depthStencil_get) + +static bool js_cc_gfx_SubpassInfo_depthStencilResolve_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilResolve, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_depthStencilResolve_set) + +static bool js_cc_gfx_SubpassInfo_depthStencilResolve_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilResolve, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_depthStencilResolve_get) + +static bool js_cc_gfx_SubpassInfo_shadingRate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadingRate, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_shadingRate_set) + +static bool js_cc_gfx_SubpassInfo_shadingRate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadingRate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_shadingRate_get) + +static bool js_cc_gfx_SubpassInfo_depthResolveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthResolveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_depthResolveMode_set) + +static bool js_cc_gfx_SubpassInfo_depthResolveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthResolveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthResolveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_depthResolveMode_get) + +static bool js_cc_gfx_SubpassInfo_stencilResolveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilResolveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_stencilResolveMode_set) + +static bool js_cc_gfx_SubpassInfo_stencilResolveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilResolveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilResolveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_stencilResolveMode_get) + +static bool js_cc_gfx_SubpassInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + cc::gfx::SubpassInfo *arg2 = 0 ; + cc::gfx::SubpassInfo temp2 ; + cc::gfx::SubpassInfo *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(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::gfx::SubpassInfo *) &(arg1)->copy((cc::gfx::SubpassInfo 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_gfx_SubpassInfo_copy) + +static bool js_new_cc_gfx_SubpassInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SubpassInfo *result; + result = (cc::gfx::SubpassInfo *)new cc::gfx::SubpassInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SubpassInfo, __jsb_cc_gfx_SubpassInfo_class, js_delete_cc_gfx_SubpassInfo) + +static bool js_delete_cc_gfx_SubpassInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SubpassInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("inputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->inputs), ctx); + } + + + json->getProperty("colors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colors), ctx); + } + + + json->getProperty("resolves", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->resolves), ctx); + } + + + json->getProperty("preserves", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->preserves), ctx); + } + + + json->getProperty("depthStencil", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencil), ctx); + } + + + json->getProperty("depthStencilResolve", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilResolve), ctx); + } + + + json->getProperty("shadingRate", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadingRate), ctx); + } + + + json->getProperty("depthResolveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthResolveMode), ctx); + } + + + json->getProperty("stencilResolveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilResolveMode), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SubpassInfo(se::Object* obj) { + auto* cls = se::Class::create("SubpassInfo", obj, nullptr, _SE(js_new_cc_gfx_SubpassInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("inputs", _SE(js_cc_gfx_SubpassInfo_inputs_get), _SE(js_cc_gfx_SubpassInfo_inputs_set)); + cls->defineProperty("colors", _SE(js_cc_gfx_SubpassInfo_colors_get), _SE(js_cc_gfx_SubpassInfo_colors_set)); + cls->defineProperty("resolves", _SE(js_cc_gfx_SubpassInfo_resolves_get), _SE(js_cc_gfx_SubpassInfo_resolves_set)); + cls->defineProperty("preserves", _SE(js_cc_gfx_SubpassInfo_preserves_get), _SE(js_cc_gfx_SubpassInfo_preserves_set)); + cls->defineProperty("depthStencil", _SE(js_cc_gfx_SubpassInfo_depthStencil_get), _SE(js_cc_gfx_SubpassInfo_depthStencil_set)); + cls->defineProperty("depthStencilResolve", _SE(js_cc_gfx_SubpassInfo_depthStencilResolve_get), _SE(js_cc_gfx_SubpassInfo_depthStencilResolve_set)); + cls->defineProperty("shadingRate", _SE(js_cc_gfx_SubpassInfo_shadingRate_get), _SE(js_cc_gfx_SubpassInfo_shadingRate_set)); + cls->defineProperty("depthResolveMode", _SE(js_cc_gfx_SubpassInfo_depthResolveMode_get), _SE(js_cc_gfx_SubpassInfo_depthResolveMode_set)); + cls->defineProperty("stencilResolveMode", _SE(js_cc_gfx_SubpassInfo_stencilResolveMode_get), _SE(js_cc_gfx_SubpassInfo_stencilResolveMode_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SubpassInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SubpassInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SubpassInfo_proto = cls->getProto(); + __jsb_cc_gfx_SubpassInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SubpassDependency_class = nullptr; +se::Object* __jsb_cc_gfx_SubpassDependency_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SubpassDependency) + +static bool js_cc_gfx_SubpassDependency_srcSubpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcSubpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_srcSubpass_set) + +static bool js_cc_gfx_SubpassDependency_srcSubpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcSubpass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_srcSubpass_get) + +static bool js_cc_gfx_SubpassDependency_dstSubpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstSubpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_dstSubpass_set) + +static bool js_cc_gfx_SubpassDependency_dstSubpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstSubpass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_dstSubpass_get) + +static bool js_cc_gfx_SubpassDependency_generalBarrier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->generalBarrier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_generalBarrier_set) + +static bool js_cc_gfx_SubpassDependency_generalBarrier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->generalBarrier, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->generalBarrier, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_generalBarrier_get) + +static bool js_cc_gfx_SubpassDependency_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_prevAccesses_set) + +static bool js_cc_gfx_SubpassDependency_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_prevAccesses_get) + +static bool js_cc_gfx_SubpassDependency_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_nextAccesses_set) + +static bool js_cc_gfx_SubpassDependency_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_nextAccesses_get) + +static bool js_cc_gfx_SubpassDependency_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + cc::gfx::SubpassDependency *arg2 = 0 ; + cc::gfx::SubpassDependency temp2 ; + cc::gfx::SubpassDependency *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(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::gfx::SubpassDependency *) &(arg1)->copy((cc::gfx::SubpassDependency 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_gfx_SubpassDependency_copy) + +static bool js_new_cc_gfx_SubpassDependency(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SubpassDependency *result; + result = (cc::gfx::SubpassDependency *)new cc::gfx::SubpassDependency(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SubpassDependency, __jsb_cc_gfx_SubpassDependency_class, js_delete_cc_gfx_SubpassDependency) + +static bool js_delete_cc_gfx_SubpassDependency(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SubpassDependency) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassDependency * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcSubpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcSubpass), ctx); + } + + + json->getProperty("dstSubpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstSubpass), ctx); + } + + + json->getProperty("generalBarrier", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->generalBarrier), ctx); + } + + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SubpassDependency(se::Object* obj) { + auto* cls = se::Class::create("SubpassDependency", obj, nullptr, _SE(js_new_cc_gfx_SubpassDependency)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcSubpass", _SE(js_cc_gfx_SubpassDependency_srcSubpass_get), _SE(js_cc_gfx_SubpassDependency_srcSubpass_set)); + cls->defineProperty("dstSubpass", _SE(js_cc_gfx_SubpassDependency_dstSubpass_get), _SE(js_cc_gfx_SubpassDependency_dstSubpass_set)); + cls->defineProperty("generalBarrier", _SE(js_cc_gfx_SubpassDependency_generalBarrier_get), _SE(js_cc_gfx_SubpassDependency_generalBarrier_set)); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_SubpassDependency_prevAccesses_get), _SE(js_cc_gfx_SubpassDependency_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_SubpassDependency_nextAccesses_get), _SE(js_cc_gfx_SubpassDependency_nextAccesses_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SubpassDependency_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SubpassDependency)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SubpassDependency_proto = cls->getProto(); + __jsb_cc_gfx_SubpassDependency_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_RenderPassInfo_class = nullptr; +se::Object* __jsb_cc_gfx_RenderPassInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_RenderPassInfo) + +static bool js_cc_gfx_RenderPassInfo_colorAttachments_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorAttachments, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_colorAttachments_set) + +static bool js_cc_gfx_RenderPassInfo_colorAttachments_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorAttachments, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorAttachments, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_colorAttachments_get) + +static bool js_cc_gfx_RenderPassInfo_depthStencilAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilAttachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_depthStencilAttachment_set) + +static bool js_cc_gfx_RenderPassInfo_depthStencilAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilAttachment, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilAttachment, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_depthStencilAttachment_get) + +static bool js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilResolveAttachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_set) + +static bool js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilResolveAttachment, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilResolveAttachment, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_get) + +static bool js_cc_gfx_RenderPassInfo_subpasses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpasses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_subpasses_set) + +static bool js_cc_gfx_RenderPassInfo_subpasses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpasses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpasses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_subpasses_get) + +static bool js_cc_gfx_RenderPassInfo_dependencies_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dependencies, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_dependencies_set) + +static bool js_cc_gfx_RenderPassInfo_dependencies_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dependencies, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dependencies, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_dependencies_get) + +static bool js_cc_gfx_RenderPassInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + cc::gfx::RenderPassInfo *arg2 = 0 ; + cc::gfx::RenderPassInfo temp2 ; + cc::gfx::RenderPassInfo *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(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::gfx::RenderPassInfo *) &(arg1)->copy((cc::gfx::RenderPassInfo 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_gfx_RenderPassInfo_copy) + +static bool js_new_cc_gfx_RenderPassInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::RenderPassInfo *result; + result = (cc::gfx::RenderPassInfo *)new cc::gfx::RenderPassInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_RenderPassInfo, __jsb_cc_gfx_RenderPassInfo_class, js_delete_cc_gfx_RenderPassInfo) + +static bool js_delete_cc_gfx_RenderPassInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_RenderPassInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RenderPassInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("colorAttachments", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorAttachments), ctx); + } + + + json->getProperty("depthStencilAttachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilAttachment), ctx); + } + + + json->getProperty("depthStencilResolveAttachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilResolveAttachment), ctx); + } + + + json->getProperty("subpasses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpasses), ctx); + } + + + json->getProperty("dependencies", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dependencies), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_RenderPassInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderPassInfo", obj, nullptr, _SE(js_new_cc_gfx_RenderPassInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("colorAttachments", _SE(js_cc_gfx_RenderPassInfo_colorAttachments_get), _SE(js_cc_gfx_RenderPassInfo_colorAttachments_set)); + cls->defineProperty("depthStencilAttachment", _SE(js_cc_gfx_RenderPassInfo_depthStencilAttachment_get), _SE(js_cc_gfx_RenderPassInfo_depthStencilAttachment_set)); + cls->defineProperty("depthStencilResolveAttachment", _SE(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_get), _SE(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_set)); + cls->defineProperty("subpasses", _SE(js_cc_gfx_RenderPassInfo_subpasses_get), _SE(js_cc_gfx_RenderPassInfo_subpasses_set)); + cls->defineProperty("dependencies", _SE(js_cc_gfx_RenderPassInfo_dependencies_get), _SE(js_cc_gfx_RenderPassInfo_dependencies_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_RenderPassInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_RenderPassInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_RenderPassInfo_proto = cls->getProto(); + __jsb_cc_gfx_RenderPassInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ResourceRange_class = nullptr; +se::Object* __jsb_cc_gfx_ResourceRange_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ResourceRange) + +static bool js_cc_gfx_ResourceRange_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_width_set) + +static bool js_cc_gfx_ResourceRange_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_width_get) + +static bool js_cc_gfx_ResourceRange_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_height_set) + +static bool js_cc_gfx_ResourceRange_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_height_get) + +static bool js_cc_gfx_ResourceRange_depthOrArraySize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthOrArraySize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_depthOrArraySize_set) + +static bool js_cc_gfx_ResourceRange_depthOrArraySize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthOrArraySize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_depthOrArraySize_get) + +static bool js_cc_gfx_ResourceRange_firstSlice_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstSlice, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_firstSlice_set) + +static bool js_cc_gfx_ResourceRange_firstSlice_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstSlice, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_firstSlice_get) + +static bool js_cc_gfx_ResourceRange_numSlices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->numSlices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_numSlices_set) + +static bool js_cc_gfx_ResourceRange_numSlices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->numSlices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_numSlices_get) + +static bool js_cc_gfx_ResourceRange_mipLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_mipLevel_set) + +static bool js_cc_gfx_ResourceRange_mipLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_mipLevel_get) + +static bool js_cc_gfx_ResourceRange_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_levelCount_set) + +static bool js_cc_gfx_ResourceRange_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_levelCount_get) + +static bool js_cc_gfx_ResourceRange_basePlane_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->basePlane, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_basePlane_set) + +static bool js_cc_gfx_ResourceRange_basePlane_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->basePlane, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_basePlane_get) + +static bool js_cc_gfx_ResourceRange_planeCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->planeCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_planeCount_set) + +static bool js_cc_gfx_ResourceRange_planeCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->planeCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_planeCount_get) + +static bool js_new_cc_gfx_ResourceRange(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ResourceRange *result; + result = (cc::gfx::ResourceRange *)new cc::gfx::ResourceRange(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ResourceRange, __jsb_cc_gfx_ResourceRange_class, js_delete_cc_gfx_ResourceRange) + +static bool js_delete_cc_gfx_ResourceRange(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ResourceRange) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ResourceRange * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("depthOrArraySize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthOrArraySize), ctx); + } + + + json->getProperty("firstSlice", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstSlice), ctx); + } + + + json->getProperty("numSlices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->numSlices), ctx); + } + + + json->getProperty("mipLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipLevel), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("basePlane", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->basePlane), ctx); + } + + + json->getProperty("planeCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->planeCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ResourceRange(se::Object* obj) { + auto* cls = se::Class::create("ResourceRange", obj, nullptr, _SE(js_new_cc_gfx_ResourceRange)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_gfx_ResourceRange_width_get), _SE(js_cc_gfx_ResourceRange_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_ResourceRange_height_get), _SE(js_cc_gfx_ResourceRange_height_set)); + cls->defineProperty("depthOrArraySize", _SE(js_cc_gfx_ResourceRange_depthOrArraySize_get), _SE(js_cc_gfx_ResourceRange_depthOrArraySize_set)); + cls->defineProperty("firstSlice", _SE(js_cc_gfx_ResourceRange_firstSlice_get), _SE(js_cc_gfx_ResourceRange_firstSlice_set)); + cls->defineProperty("numSlices", _SE(js_cc_gfx_ResourceRange_numSlices_get), _SE(js_cc_gfx_ResourceRange_numSlices_set)); + cls->defineProperty("mipLevel", _SE(js_cc_gfx_ResourceRange_mipLevel_get), _SE(js_cc_gfx_ResourceRange_mipLevel_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_ResourceRange_levelCount_get), _SE(js_cc_gfx_ResourceRange_levelCount_set)); + cls->defineProperty("basePlane", _SE(js_cc_gfx_ResourceRange_basePlane_get), _SE(js_cc_gfx_ResourceRange_basePlane_set)); + cls->defineProperty("planeCount", _SE(js_cc_gfx_ResourceRange_planeCount_get), _SE(js_cc_gfx_ResourceRange_planeCount_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ResourceRange)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ResourceRange_proto = cls->getProto(); + __jsb_cc_gfx_ResourceRange_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_GeneralBarrierInfo_class = nullptr; +se::Object* __jsb_cc_gfx_GeneralBarrierInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrierInfo) + +static bool js_cc_gfx_GeneralBarrierInfo_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo_prevAccesses_set) + +static bool js_cc_gfx_GeneralBarrierInfo_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo_prevAccesses_get) + +static bool js_cc_gfx_GeneralBarrierInfo_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo_nextAccesses_set) + +static bool js_cc_gfx_GeneralBarrierInfo_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo_nextAccesses_get) + +static bool js_cc_gfx_GeneralBarrierInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo_type_set) + +static bool js_cc_gfx_GeneralBarrierInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo_type_get) + +static bool js_cc_gfx_GeneralBarrierInfo__padding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_padding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo__padding_set) + +static bool js_cc_gfx_GeneralBarrierInfo__padding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_padding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo__padding_get) + +static bool js_cc_gfx_GeneralBarrierInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + cc::gfx::GeneralBarrierInfo *arg2 = 0 ; + cc::gfx::GeneralBarrierInfo temp2 ; + cc::gfx::GeneralBarrierInfo *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(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::gfx::GeneralBarrierInfo *) &(arg1)->copy((cc::gfx::GeneralBarrierInfo 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_gfx_GeneralBarrierInfo_copy) + +static bool js_new_cc_gfx_GeneralBarrierInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::GeneralBarrierInfo *result; + result = (cc::gfx::GeneralBarrierInfo *)new cc::gfx::GeneralBarrierInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_GeneralBarrierInfo, __jsb_cc_gfx_GeneralBarrierInfo_class, js_delete_cc_gfx_GeneralBarrierInfo) + +static bool js_delete_cc_gfx_GeneralBarrierInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrierInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::GeneralBarrierInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("_padding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_padding), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_GeneralBarrierInfo(se::Object* obj) { + auto* cls = se::Class::create("GeneralBarrierInfo", obj, nullptr, _SE(js_new_cc_gfx_GeneralBarrierInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_GeneralBarrierInfo_prevAccesses_get), _SE(js_cc_gfx_GeneralBarrierInfo_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_GeneralBarrierInfo_nextAccesses_get), _SE(js_cc_gfx_GeneralBarrierInfo_nextAccesses_set)); + cls->defineProperty("type", _SE(js_cc_gfx_GeneralBarrierInfo_type_get), _SE(js_cc_gfx_GeneralBarrierInfo_type_set)); + cls->defineProperty("_padding", _SE(js_cc_gfx_GeneralBarrierInfo__padding_get), _SE(js_cc_gfx_GeneralBarrierInfo__padding_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_GeneralBarrierInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_GeneralBarrierInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_GeneralBarrierInfo_proto = cls->getProto(); + __jsb_cc_gfx_GeneralBarrierInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureBarrierInfo_class = nullptr; +se::Object* __jsb_cc_gfx_TextureBarrierInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrierInfo) + +static bool js_cc_gfx_TextureBarrierInfo_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_prevAccesses_set) + +static bool js_cc_gfx_TextureBarrierInfo_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_prevAccesses_get) + +static bool js_cc_gfx_TextureBarrierInfo_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_nextAccesses_set) + +static bool js_cc_gfx_TextureBarrierInfo_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_nextAccesses_get) + +static bool js_cc_gfx_TextureBarrierInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_type_set) + +static bool js_cc_gfx_TextureBarrierInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_type_get) + +static bool js_cc_gfx_TextureBarrierInfo_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->range, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_range_set) + +static bool js_cc_gfx_TextureBarrierInfo_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->range, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->range, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_range_get) + +static bool js_cc_gfx_TextureBarrierInfo_discardContents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->discardContents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_discardContents_set) + +static bool js_cc_gfx_TextureBarrierInfo_discardContents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->discardContents, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_discardContents_get) + +static bool js_cc_gfx_TextureBarrierInfo_srcQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_srcQueue_set) + +static bool js_cc_gfx_TextureBarrierInfo_srcQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_srcQueue_get) + +static bool js_cc_gfx_TextureBarrierInfo_dstQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_dstQueue_set) + +static bool js_cc_gfx_TextureBarrierInfo_dstQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_dstQueue_get) + +static bool js_cc_gfx_TextureBarrierInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + cc::gfx::TextureBarrierInfo *arg2 = 0 ; + cc::gfx::TextureBarrierInfo temp2 ; + cc::gfx::TextureBarrierInfo *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(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::gfx::TextureBarrierInfo *) &(arg1)->copy((cc::gfx::TextureBarrierInfo 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_gfx_TextureBarrierInfo_copy) + +static bool js_new_cc_gfx_TextureBarrierInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureBarrierInfo *result; + result = (cc::gfx::TextureBarrierInfo *)new cc::gfx::TextureBarrierInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureBarrierInfo, __jsb_cc_gfx_TextureBarrierInfo_class, js_delete_cc_gfx_TextureBarrierInfo) + +static bool js_delete_cc_gfx_TextureBarrierInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrierInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBarrierInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("range", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->range), ctx); + } + + + json->getProperty("discardContents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->discardContents), ctx); + } + + + json->getProperty("srcQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcQueue), ctx); + } + + + json->getProperty("dstQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstQueue), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureBarrierInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureBarrierInfo", obj, nullptr, _SE(js_new_cc_gfx_TextureBarrierInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_TextureBarrierInfo_prevAccesses_get), _SE(js_cc_gfx_TextureBarrierInfo_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_TextureBarrierInfo_nextAccesses_get), _SE(js_cc_gfx_TextureBarrierInfo_nextAccesses_set)); + cls->defineProperty("type", _SE(js_cc_gfx_TextureBarrierInfo_type_get), _SE(js_cc_gfx_TextureBarrierInfo_type_set)); + cls->defineProperty("range", _SE(js_cc_gfx_TextureBarrierInfo_range_get), _SE(js_cc_gfx_TextureBarrierInfo_range_set)); + cls->defineProperty("discardContents", _SE(js_cc_gfx_TextureBarrierInfo_discardContents_get), _SE(js_cc_gfx_TextureBarrierInfo_discardContents_set)); + cls->defineProperty("srcQueue", _SE(js_cc_gfx_TextureBarrierInfo_srcQueue_get), _SE(js_cc_gfx_TextureBarrierInfo_srcQueue_set)); + cls->defineProperty("dstQueue", _SE(js_cc_gfx_TextureBarrierInfo_dstQueue_get), _SE(js_cc_gfx_TextureBarrierInfo_dstQueue_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureBarrierInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureBarrierInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureBarrierInfo_proto = cls->getProto(); + __jsb_cc_gfx_TextureBarrierInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferBarrierInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BufferBarrierInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrierInfo) + +static bool js_cc_gfx_BufferBarrierInfo_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_prevAccesses_set) + +static bool js_cc_gfx_BufferBarrierInfo_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_prevAccesses_get) + +static bool js_cc_gfx_BufferBarrierInfo_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_nextAccesses_set) + +static bool js_cc_gfx_BufferBarrierInfo_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_nextAccesses_get) + +static bool js_cc_gfx_BufferBarrierInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_type_set) + +static bool js_cc_gfx_BufferBarrierInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_type_get) + +static bool js_cc_gfx_BufferBarrierInfo_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_offset_set) + +static bool js_cc_gfx_BufferBarrierInfo_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_offset_get) + +static bool js_cc_gfx_BufferBarrierInfo_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_size_set) + +static bool js_cc_gfx_BufferBarrierInfo_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_size_get) + +static bool js_cc_gfx_BufferBarrierInfo__padding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_padding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo__padding_set) + +static bool js_cc_gfx_BufferBarrierInfo__padding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_padding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo__padding_get) + +static bool js_cc_gfx_BufferBarrierInfo_discardContents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->discardContents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_discardContents_set) + +static bool js_cc_gfx_BufferBarrierInfo_discardContents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->discardContents, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_discardContents_get) + +static bool js_cc_gfx_BufferBarrierInfo_srcQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_srcQueue_set) + +static bool js_cc_gfx_BufferBarrierInfo_srcQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_srcQueue_get) + +static bool js_cc_gfx_BufferBarrierInfo_dstQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_dstQueue_set) + +static bool js_cc_gfx_BufferBarrierInfo_dstQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_dstQueue_get) + +static bool js_cc_gfx_BufferBarrierInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + cc::gfx::BufferBarrierInfo *arg2 = 0 ; + cc::gfx::BufferBarrierInfo temp2 ; + cc::gfx::BufferBarrierInfo *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(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::gfx::BufferBarrierInfo *) &(arg1)->copy((cc::gfx::BufferBarrierInfo 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_gfx_BufferBarrierInfo_copy) + +static bool js_new_cc_gfx_BufferBarrierInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferBarrierInfo *result; + result = (cc::gfx::BufferBarrierInfo *)new cc::gfx::BufferBarrierInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferBarrierInfo, __jsb_cc_gfx_BufferBarrierInfo_class, js_delete_cc_gfx_BufferBarrierInfo) + +static bool js_delete_cc_gfx_BufferBarrierInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrierInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferBarrierInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("_padding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_padding), ctx); + } + + + json->getProperty("discardContents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->discardContents), ctx); + } + + + json->getProperty("srcQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcQueue), ctx); + } + + + json->getProperty("dstQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstQueue), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferBarrierInfo(se::Object* obj) { + auto* cls = se::Class::create("BufferBarrierInfo", obj, nullptr, _SE(js_new_cc_gfx_BufferBarrierInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_BufferBarrierInfo_prevAccesses_get), _SE(js_cc_gfx_BufferBarrierInfo_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_BufferBarrierInfo_nextAccesses_get), _SE(js_cc_gfx_BufferBarrierInfo_nextAccesses_set)); + cls->defineProperty("type", _SE(js_cc_gfx_BufferBarrierInfo_type_get), _SE(js_cc_gfx_BufferBarrierInfo_type_set)); + cls->defineProperty("offset", _SE(js_cc_gfx_BufferBarrierInfo_offset_get), _SE(js_cc_gfx_BufferBarrierInfo_offset_set)); + cls->defineProperty("size", _SE(js_cc_gfx_BufferBarrierInfo_size_get), _SE(js_cc_gfx_BufferBarrierInfo_size_set)); + cls->defineProperty("_padding", _SE(js_cc_gfx_BufferBarrierInfo__padding_get), _SE(js_cc_gfx_BufferBarrierInfo__padding_set)); + cls->defineProperty("discardContents", _SE(js_cc_gfx_BufferBarrierInfo_discardContents_get), _SE(js_cc_gfx_BufferBarrierInfo_discardContents_set)); + cls->defineProperty("srcQueue", _SE(js_cc_gfx_BufferBarrierInfo_srcQueue_get), _SE(js_cc_gfx_BufferBarrierInfo_srcQueue_set)); + cls->defineProperty("dstQueue", _SE(js_cc_gfx_BufferBarrierInfo_dstQueue_get), _SE(js_cc_gfx_BufferBarrierInfo_dstQueue_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferBarrierInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferBarrierInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferBarrierInfo_proto = cls->getProto(); + __jsb_cc_gfx_BufferBarrierInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_FramebufferInfo_class = nullptr; +se::Object* __jsb_cc_gfx_FramebufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_FramebufferInfo) + +static bool js_cc_gfx_FramebufferInfo_renderPass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_renderPass_set) + +static bool js_cc_gfx_FramebufferInfo_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPass, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderPass, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_renderPass_get) + +static bool js_cc_gfx_FramebufferInfo_colorTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_colorTextures_set) + +static bool js_cc_gfx_FramebufferInfo_colorTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_colorTextures_get) + +static bool js_cc_gfx_FramebufferInfo_depthStencilTexture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilTexture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_depthStencilTexture_set) + +static bool js_cc_gfx_FramebufferInfo_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilTexture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilTexture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_depthStencilTexture_get) + +static bool js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilResolveTexture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_set) + +static bool js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilResolveTexture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilResolveTexture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_get) + +static bool js_cc_gfx_FramebufferInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + cc::gfx::FramebufferInfo *arg2 = 0 ; + cc::gfx::FramebufferInfo temp2 ; + cc::gfx::FramebufferInfo *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(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::gfx::FramebufferInfo *) &(arg1)->copy((cc::gfx::FramebufferInfo 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_gfx_FramebufferInfo_copy) + +static bool js_new_cc_gfx_FramebufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::FramebufferInfo *result; + result = (cc::gfx::FramebufferInfo *)new cc::gfx::FramebufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_FramebufferInfo, __jsb_cc_gfx_FramebufferInfo_class, js_delete_cc_gfx_FramebufferInfo) + +static bool js_delete_cc_gfx_FramebufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_FramebufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FramebufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("renderPass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPass), ctx); + } + + + json->getProperty("colorTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorTextures), ctx); + } + + + json->getProperty("depthStencilTexture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilTexture), ctx); + } + + + json->getProperty("depthStencilResolveTexture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilResolveTexture), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_FramebufferInfo(se::Object* obj) { + auto* cls = se::Class::create("FramebufferInfo", obj, nullptr, _SE(js_new_cc_gfx_FramebufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderPass", _SE(js_cc_gfx_FramebufferInfo_renderPass_get), _SE(js_cc_gfx_FramebufferInfo_renderPass_set)); + cls->defineProperty("colorTextures", _SE(js_cc_gfx_FramebufferInfo_colorTextures_get), _SE(js_cc_gfx_FramebufferInfo_colorTextures_set)); + cls->defineProperty("depthStencilTexture", _SE(js_cc_gfx_FramebufferInfo_depthStencilTexture_get), _SE(js_cc_gfx_FramebufferInfo_depthStencilTexture_set)); + cls->defineProperty("depthStencilResolveTexture", _SE(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_get), _SE(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_FramebufferInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_FramebufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_FramebufferInfo_proto = cls->getProto(); + __jsb_cc_gfx_FramebufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetLayoutBinding_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetLayoutBinding_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutBinding) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_binding_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_binding_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->descriptorType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->descriptorType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->descriptorType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_count_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_count_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_access_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->access, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_access_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_access_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->access, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->access, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_access_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->viewDimension, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->viewDimension, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->viewDimension, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_sampleType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampleType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_sampleType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampleType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampleType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_format_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_format_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->immutableSamplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->immutableSamplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->immutableSamplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + cc::gfx::DescriptorSetLayoutBinding *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutBinding temp2 ; + cc::gfx::DescriptorSetLayoutBinding *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(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::gfx::DescriptorSetLayoutBinding *) &(arg1)->copy((cc::gfx::DescriptorSetLayoutBinding 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_gfx_DescriptorSetLayoutBinding_copy) + +static bool js_new_cc_gfx_DescriptorSetLayoutBinding(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DescriptorSetLayoutBinding *result; + result = (cc::gfx::DescriptorSetLayoutBinding *)new cc::gfx::DescriptorSetLayoutBinding(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DescriptorSetLayoutBinding, __jsb_cc_gfx_DescriptorSetLayoutBinding_class, js_delete_cc_gfx_DescriptorSetLayoutBinding) + +static bool js_delete_cc_gfx_DescriptorSetLayoutBinding(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutBinding) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutBinding * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("descriptorType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->descriptorType), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + json->getProperty("access", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->access), ctx); + } + + + json->getProperty("viewDimension", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->viewDimension), ctx); + } + + + json->getProperty("sampleType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampleType), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("immutableSamplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->immutableSamplers), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DescriptorSetLayoutBinding(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayoutBinding", obj, nullptr, _SE(js_new_cc_gfx_DescriptorSetLayoutBinding)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_gfx_DescriptorSetLayoutBinding_binding_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_binding_set)); + cls->defineProperty("descriptorType", _SE(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_set)); + cls->defineProperty("count", _SE(js_cc_gfx_DescriptorSetLayoutBinding_count_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_set)); + cls->defineProperty("access", _SE(js_cc_gfx_DescriptorSetLayoutBinding_access_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_access_set)); + cls->defineProperty("viewDimension", _SE(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_set)); + cls->defineProperty("sampleType", _SE(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_set)); + cls->defineProperty("format", _SE(js_cc_gfx_DescriptorSetLayoutBinding_format_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_format_set)); + cls->defineProperty("immutableSamplers", _SE(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DescriptorSetLayoutBinding_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetLayoutBinding)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetLayoutBinding_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetLayoutBinding_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetLayoutInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetLayoutInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutInfo) + +static bool js_cc_gfx_DescriptorSetLayoutInfo_bindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutInfo *arg1 = (cc::gfx::DescriptorSetLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutInfo_bindings_set) + +static bool js_cc_gfx_DescriptorSetLayoutInfo_bindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutInfo *arg1 = (cc::gfx::DescriptorSetLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindings, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindings, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutInfo_bindings_get) + +static bool js_cc_gfx_DescriptorSetLayoutInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutInfo *arg1 = (cc::gfx::DescriptorSetLayoutInfo *) NULL ; + cc::gfx::DescriptorSetLayoutInfo *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutInfo temp2 ; + cc::gfx::DescriptorSetLayoutInfo *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(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::gfx::DescriptorSetLayoutInfo *) &(arg1)->copy((cc::gfx::DescriptorSetLayoutInfo 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_gfx_DescriptorSetLayoutInfo_copy) + +static bool js_new_cc_gfx_DescriptorSetLayoutInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DescriptorSetLayoutInfo *result; + result = (cc::gfx::DescriptorSetLayoutInfo *)new cc::gfx::DescriptorSetLayoutInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DescriptorSetLayoutInfo, __jsb_cc_gfx_DescriptorSetLayoutInfo_class, js_delete_cc_gfx_DescriptorSetLayoutInfo) + +static bool js_delete_cc_gfx_DescriptorSetLayoutInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindings), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DescriptorSetLayoutInfo(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayoutInfo", obj, nullptr, _SE(js_new_cc_gfx_DescriptorSetLayoutInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindings", _SE(js_cc_gfx_DescriptorSetLayoutInfo_bindings_get), _SE(js_cc_gfx_DescriptorSetLayoutInfo_bindings_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DescriptorSetLayoutInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetLayoutInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetLayoutInfo_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetLayoutInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetInfo) + +static bool js_cc_gfx_DescriptorSetInfo_layout_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetInfo *arg1 = (cc::gfx::DescriptorSetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layout, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetInfo_layout_set) + +static bool js_cc_gfx_DescriptorSetInfo_layout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetInfo *arg1 = (cc::gfx::DescriptorSetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layout, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->layout, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetInfo_layout_get) + +static bool js_cc_gfx_DescriptorSetInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetInfo *arg1 = (cc::gfx::DescriptorSetInfo *) NULL ; + cc::gfx::DescriptorSetInfo *arg2 = 0 ; + cc::gfx::DescriptorSetInfo temp2 ; + cc::gfx::DescriptorSetInfo *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(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::gfx::DescriptorSetInfo *) &(arg1)->copy((cc::gfx::DescriptorSetInfo 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_gfx_DescriptorSetInfo_copy) + +static bool js_new_cc_gfx_DescriptorSetInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DescriptorSetInfo *result; + result = (cc::gfx::DescriptorSetInfo *)new cc::gfx::DescriptorSetInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DescriptorSetInfo, __jsb_cc_gfx_DescriptorSetInfo_class, js_delete_cc_gfx_DescriptorSetInfo) + +static bool js_delete_cc_gfx_DescriptorSetInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("layout", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layout), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DescriptorSetInfo(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetInfo", obj, nullptr, _SE(js_new_cc_gfx_DescriptorSetInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("layout", _SE(js_cc_gfx_DescriptorSetInfo_layout_get), _SE(js_cc_gfx_DescriptorSetInfo_layout_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DescriptorSetInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetInfo_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineLayoutInfo_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineLayoutInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayoutInfo) + +static bool js_cc_gfx_PipelineLayoutInfo_setLayouts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayoutInfo *arg1 = (cc::gfx::PipelineLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->setLayouts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineLayoutInfo_setLayouts_set) + +static bool js_cc_gfx_PipelineLayoutInfo_setLayouts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineLayoutInfo *arg1 = (cc::gfx::PipelineLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->setLayouts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->setLayouts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineLayoutInfo_setLayouts_get) + +static bool js_cc_gfx_PipelineLayoutInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayoutInfo *arg1 = (cc::gfx::PipelineLayoutInfo *) NULL ; + cc::gfx::PipelineLayoutInfo *arg2 = 0 ; + cc::gfx::PipelineLayoutInfo temp2 ; + cc::gfx::PipelineLayoutInfo *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(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::gfx::PipelineLayoutInfo *) &(arg1)->copy((cc::gfx::PipelineLayoutInfo 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_gfx_PipelineLayoutInfo_copy) + +static bool js_new_cc_gfx_PipelineLayoutInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::PipelineLayoutInfo *result; + result = (cc::gfx::PipelineLayoutInfo *)new cc::gfx::PipelineLayoutInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_PipelineLayoutInfo, __jsb_cc_gfx_PipelineLayoutInfo_class, js_delete_cc_gfx_PipelineLayoutInfo) + +static bool js_delete_cc_gfx_PipelineLayoutInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayoutInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineLayoutInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("setLayouts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->setLayouts), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_PipelineLayoutInfo(se::Object* obj) { + auto* cls = se::Class::create("PipelineLayoutInfo", obj, nullptr, _SE(js_new_cc_gfx_PipelineLayoutInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("setLayouts", _SE(js_cc_gfx_PipelineLayoutInfo_setLayouts_get), _SE(js_cc_gfx_PipelineLayoutInfo_setLayouts_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_PipelineLayoutInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineLayoutInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineLayoutInfo_proto = cls->getProto(); + __jsb_cc_gfx_PipelineLayoutInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_InputState_class = nullptr; +se::Object* __jsb_cc_gfx_InputState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_InputState) + +static bool js_cc_gfx_InputState_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputState *arg1 = (cc::gfx::InputState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputState_attributes_set) + +static bool js_cc_gfx_InputState_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputState *arg1 = (cc::gfx::InputState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputState_attributes_get) + +static bool js_cc_gfx_InputState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputState *arg1 = (cc::gfx::InputState *) NULL ; + cc::gfx::InputState *arg2 = 0 ; + cc::gfx::InputState temp2 ; + cc::gfx::InputState *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(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::gfx::InputState *) &(arg1)->copy((cc::gfx::InputState 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_gfx_InputState_copy) + +static bool js_new_cc_gfx_InputState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::InputState *result; + result = (cc::gfx::InputState *)new cc::gfx::InputState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_InputState, __jsb_cc_gfx_InputState_class, js_delete_cc_gfx_InputState) + +static bool js_delete_cc_gfx_InputState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_InputState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_InputState(se::Object* obj) { + auto* cls = se::Class::create("InputState", obj, nullptr, _SE(js_new_cc_gfx_InputState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attributes", _SE(js_cc_gfx_InputState_attributes_get), _SE(js_cc_gfx_InputState_attributes_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_InputState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_InputState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_InputState_proto = cls->getProto(); + __jsb_cc_gfx_InputState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_RasterizerState_class = nullptr; +se::Object* __jsb_cc_gfx_RasterizerState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_RasterizerState) + +static bool js_cc_gfx_RasterizerState_isDiscard_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDiscard, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isDiscard_set) + +static bool js_cc_gfx_RasterizerState_isDiscard_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDiscard, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isDiscard_get) + +static bool js_cc_gfx_RasterizerState_polygonMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->polygonMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_polygonMode_set) + +static bool js_cc_gfx_RasterizerState_polygonMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->polygonMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->polygonMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_polygonMode_get) + +static bool js_cc_gfx_RasterizerState_shadeModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadeModel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_shadeModel_set) + +static bool js_cc_gfx_RasterizerState_shadeModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadeModel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shadeModel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_shadeModel_get) + +static bool js_cc_gfx_RasterizerState_cullMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cullMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_cullMode_set) + +static bool js_cc_gfx_RasterizerState_cullMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cullMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cullMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_cullMode_get) + +static bool js_cc_gfx_RasterizerState_isFrontFaceCCW_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isFrontFaceCCW, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isFrontFaceCCW_set) + +static bool js_cc_gfx_RasterizerState_isFrontFaceCCW_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isFrontFaceCCW, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isFrontFaceCCW_get) + +static bool js_cc_gfx_RasterizerState_depthBiasEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasEnabled, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBiasEnabled_set) + +static bool js_cc_gfx_RasterizerState_depthBiasEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasEnabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBiasEnabled_get) + +static bool js_cc_gfx_RasterizerState_depthBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBias, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBias_set) + +static bool js_cc_gfx_RasterizerState_depthBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBias, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBias_get) + +static bool js_cc_gfx_RasterizerState_depthBiasClamp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasClamp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBiasClamp_set) + +static bool js_cc_gfx_RasterizerState_depthBiasClamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasClamp, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBiasClamp_get) + +static bool js_cc_gfx_RasterizerState_depthBiasSlop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasSlop, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBiasSlop_set) + +static bool js_cc_gfx_RasterizerState_depthBiasSlop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasSlop, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBiasSlop_get) + +static bool js_cc_gfx_RasterizerState_isDepthClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDepthClip, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isDepthClip_set) + +static bool js_cc_gfx_RasterizerState_isDepthClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDepthClip, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isDepthClip_get) + +static bool js_cc_gfx_RasterizerState_isMultisample_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isMultisample, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isMultisample_set) + +static bool js_cc_gfx_RasterizerState_isMultisample_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isMultisample, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isMultisample_get) + +static bool js_cc_gfx_RasterizerState_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_lineWidth_set) + +static bool js_cc_gfx_RasterizerState_lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lineWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_lineWidth_get) + +static bool js_cc_gfx_RasterizerState_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_RasterizerState_reset) + +static bool js_cc_gfx_RasterizerState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + cc::gfx::RasterizerState *arg2 = 0 ; + cc::gfx::RasterizerState temp2 ; + cc::gfx::RasterizerState *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(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::gfx::RasterizerState *) &(arg1)->copy((cc::gfx::RasterizerState 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_gfx_RasterizerState_copy) + +static bool js_new_cc_gfx_RasterizerState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::RasterizerState *result; + result = (cc::gfx::RasterizerState *)new cc::gfx::RasterizerState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_RasterizerState, __jsb_cc_gfx_RasterizerState_class, js_delete_cc_gfx_RasterizerState) + +static bool js_delete_cc_gfx_RasterizerState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_RasterizerState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RasterizerState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isDiscard", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDiscard), ctx); + } + + + json->getProperty("polygonMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->polygonMode), ctx); + } + + + json->getProperty("shadeModel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadeModel), ctx); + } + + + json->getProperty("cullMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cullMode), ctx); + } + + + json->getProperty("isFrontFaceCCW", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isFrontFaceCCW), ctx); + } + + + json->getProperty("depthBiasEnabled", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasEnabled), ctx); + } + + + json->getProperty("depthBias", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBias), ctx); + } + + + json->getProperty("depthBiasClamp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasClamp), ctx); + } + + + json->getProperty("depthBiasSlop", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasSlop), ctx); + } + + + json->getProperty("isDepthClip", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDepthClip), ctx); + } + + + json->getProperty("isMultisample", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isMultisample), ctx); + } + + + json->getProperty("lineWidth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lineWidth), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_RasterizerState(se::Object* obj) { + auto* cls = se::Class::create("RasterizerState", obj, nullptr, _SE(js_new_cc_gfx_RasterizerState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isDiscard", _SE(js_cc_gfx_RasterizerState_isDiscard_get), _SE(js_cc_gfx_RasterizerState_isDiscard_set)); + cls->defineProperty("polygonMode", _SE(js_cc_gfx_RasterizerState_polygonMode_get), _SE(js_cc_gfx_RasterizerState_polygonMode_set)); + cls->defineProperty("shadeModel", _SE(js_cc_gfx_RasterizerState_shadeModel_get), _SE(js_cc_gfx_RasterizerState_shadeModel_set)); + cls->defineProperty("cullMode", _SE(js_cc_gfx_RasterizerState_cullMode_get), _SE(js_cc_gfx_RasterizerState_cullMode_set)); + cls->defineProperty("isFrontFaceCCW", _SE(js_cc_gfx_RasterizerState_isFrontFaceCCW_get), _SE(js_cc_gfx_RasterizerState_isFrontFaceCCW_set)); + cls->defineProperty("depthBiasEnabled", _SE(js_cc_gfx_RasterizerState_depthBiasEnabled_get), _SE(js_cc_gfx_RasterizerState_depthBiasEnabled_set)); + cls->defineProperty("depthBias", _SE(js_cc_gfx_RasterizerState_depthBias_get), _SE(js_cc_gfx_RasterizerState_depthBias_set)); + cls->defineProperty("depthBiasClamp", _SE(js_cc_gfx_RasterizerState_depthBiasClamp_get), _SE(js_cc_gfx_RasterizerState_depthBiasClamp_set)); + cls->defineProperty("depthBiasSlop", _SE(js_cc_gfx_RasterizerState_depthBiasSlop_get), _SE(js_cc_gfx_RasterizerState_depthBiasSlop_set)); + cls->defineProperty("isDepthClip", _SE(js_cc_gfx_RasterizerState_isDepthClip_get), _SE(js_cc_gfx_RasterizerState_isDepthClip_set)); + cls->defineProperty("isMultisample", _SE(js_cc_gfx_RasterizerState_isMultisample_get), _SE(js_cc_gfx_RasterizerState_isMultisample_set)); + cls->defineProperty("lineWidth", _SE(js_cc_gfx_RasterizerState_lineWidth_get), _SE(js_cc_gfx_RasterizerState_lineWidth_set)); + + cls->defineFunction("reset", _SE(js_cc_gfx_RasterizerState_reset)); + cls->defineFunction("copy", _SE(js_cc_gfx_RasterizerState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_RasterizerState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_RasterizerState_proto = cls->getProto(); + __jsb_cc_gfx_RasterizerState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DepthStencilState_class = nullptr; +se::Object* __jsb_cc_gfx_DepthStencilState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilState) + +static bool js_cc_gfx_DepthStencilState_depthTest_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthTest, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_depthTest_set) + +static bool js_cc_gfx_DepthStencilState_depthTest_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthTest, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_depthTest_get) + +static bool js_cc_gfx_DepthStencilState_depthWrite_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthWrite, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_depthWrite_set) + +static bool js_cc_gfx_DepthStencilState_depthWrite_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthWrite, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_depthWrite_get) + +static bool js_cc_gfx_DepthStencilState_depthFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_depthFunc_set) + +static bool js_cc_gfx_DepthStencilState_depthFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_depthFunc_get) + +static bool js_cc_gfx_DepthStencilState_stencilTestFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilTestFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilTestFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilTestFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilFuncFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFuncFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilFuncFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFuncFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilReadMaskFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilReadMaskFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFailOpFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFailOpFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilZFailOpFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilZFailOpFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilPassOpFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilPassOpFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilRefFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilRefFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilRefFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilRefFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilTestBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilTestBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilTestBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilTestBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilFuncBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFuncBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilFuncBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFuncBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilReadMaskBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilReadMaskBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFailOpBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFailOpBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilZFailOpBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilZFailOpBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilPassOpBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilPassOpBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilRefBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilRefBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilRefBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilRefBack_get) + +static bool js_cc_gfx_DepthStencilState_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DepthStencilState_reset) + +static bool js_cc_gfx_DepthStencilState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + cc::gfx::DepthStencilState *arg2 = 0 ; + cc::gfx::DepthStencilState temp2 ; + cc::gfx::DepthStencilState *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(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::gfx::DepthStencilState *) &(arg1)->copy((cc::gfx::DepthStencilState 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_gfx_DepthStencilState_copy) + +static bool js_new_cc_gfx_DepthStencilState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DepthStencilState *result; + result = (cc::gfx::DepthStencilState *)new cc::gfx::DepthStencilState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DepthStencilState, __jsb_cc_gfx_DepthStencilState_class, js_delete_cc_gfx_DepthStencilState) + +static bool js_delete_cc_gfx_DepthStencilState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("depthTest", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthTest), ctx); + } + + + json->getProperty("depthWrite", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthWrite), ctx); + } + + + json->getProperty("depthFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthFunc), ctx); + } + + + json->getProperty("stencilTestFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestFront), ctx); + } + + + json->getProperty("stencilFuncFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncFront), ctx); + } + + + json->getProperty("stencilReadMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskFront), ctx); + } + + + json->getProperty("stencilWriteMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskFront), ctx); + } + + + json->getProperty("stencilFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpFront), ctx); + } + + + json->getProperty("stencilZFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpFront), ctx); + } + + + json->getProperty("stencilPassOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpFront), ctx); + } + + + json->getProperty("stencilRefFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefFront), ctx); + } + + + json->getProperty("stencilTestBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestBack), ctx); + } + + + json->getProperty("stencilFuncBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncBack), ctx); + } + + + json->getProperty("stencilReadMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskBack), ctx); + } + + + json->getProperty("stencilWriteMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskBack), ctx); + } + + + json->getProperty("stencilFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpBack), ctx); + } + + + json->getProperty("stencilZFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpBack), ctx); + } + + + json->getProperty("stencilPassOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpBack), ctx); + } + + + json->getProperty("stencilRefBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefBack), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DepthStencilState(se::Object* obj) { + auto* cls = se::Class::create("DepthStencilState", obj, nullptr, _SE(js_new_cc_gfx_DepthStencilState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("depthTest", _SE(js_cc_gfx_DepthStencilState_depthTest_get), _SE(js_cc_gfx_DepthStencilState_depthTest_set)); + cls->defineProperty("depthWrite", _SE(js_cc_gfx_DepthStencilState_depthWrite_get), _SE(js_cc_gfx_DepthStencilState_depthWrite_set)); + cls->defineProperty("depthFunc", _SE(js_cc_gfx_DepthStencilState_depthFunc_get), _SE(js_cc_gfx_DepthStencilState_depthFunc_set)); + cls->defineProperty("stencilTestFront", _SE(js_cc_gfx_DepthStencilState_stencilTestFront_get), _SE(js_cc_gfx_DepthStencilState_stencilTestFront_set)); + cls->defineProperty("stencilFuncFront", _SE(js_cc_gfx_DepthStencilState_stencilFuncFront_get), _SE(js_cc_gfx_DepthStencilState_stencilFuncFront_set)); + cls->defineProperty("stencilReadMaskFront", _SE(js_cc_gfx_DepthStencilState_stencilReadMaskFront_get), _SE(js_cc_gfx_DepthStencilState_stencilReadMaskFront_set)); + cls->defineProperty("stencilWriteMaskFront", _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_get), _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_set)); + cls->defineProperty("stencilFailOpFront", _SE(js_cc_gfx_DepthStencilState_stencilFailOpFront_get), _SE(js_cc_gfx_DepthStencilState_stencilFailOpFront_set)); + cls->defineProperty("stencilZFailOpFront", _SE(js_cc_gfx_DepthStencilState_stencilZFailOpFront_get), _SE(js_cc_gfx_DepthStencilState_stencilZFailOpFront_set)); + cls->defineProperty("stencilPassOpFront", _SE(js_cc_gfx_DepthStencilState_stencilPassOpFront_get), _SE(js_cc_gfx_DepthStencilState_stencilPassOpFront_set)); + cls->defineProperty("stencilRefFront", _SE(js_cc_gfx_DepthStencilState_stencilRefFront_get), _SE(js_cc_gfx_DepthStencilState_stencilRefFront_set)); + cls->defineProperty("stencilTestBack", _SE(js_cc_gfx_DepthStencilState_stencilTestBack_get), _SE(js_cc_gfx_DepthStencilState_stencilTestBack_set)); + cls->defineProperty("stencilFuncBack", _SE(js_cc_gfx_DepthStencilState_stencilFuncBack_get), _SE(js_cc_gfx_DepthStencilState_stencilFuncBack_set)); + cls->defineProperty("stencilReadMaskBack", _SE(js_cc_gfx_DepthStencilState_stencilReadMaskBack_get), _SE(js_cc_gfx_DepthStencilState_stencilReadMaskBack_set)); + cls->defineProperty("stencilWriteMaskBack", _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_get), _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_set)); + cls->defineProperty("stencilFailOpBack", _SE(js_cc_gfx_DepthStencilState_stencilFailOpBack_get), _SE(js_cc_gfx_DepthStencilState_stencilFailOpBack_set)); + cls->defineProperty("stencilZFailOpBack", _SE(js_cc_gfx_DepthStencilState_stencilZFailOpBack_get), _SE(js_cc_gfx_DepthStencilState_stencilZFailOpBack_set)); + cls->defineProperty("stencilPassOpBack", _SE(js_cc_gfx_DepthStencilState_stencilPassOpBack_get), _SE(js_cc_gfx_DepthStencilState_stencilPassOpBack_set)); + cls->defineProperty("stencilRefBack", _SE(js_cc_gfx_DepthStencilState_stencilRefBack_get), _SE(js_cc_gfx_DepthStencilState_stencilRefBack_set)); + + cls->defineFunction("reset", _SE(js_cc_gfx_DepthStencilState_reset)); + cls->defineFunction("copy", _SE(js_cc_gfx_DepthStencilState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DepthStencilState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DepthStencilState_proto = cls->getProto(); + __jsb_cc_gfx_DepthStencilState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BlendTarget_class = nullptr; +se::Object* __jsb_cc_gfx_BlendTarget_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BlendTarget) + +static bool js_cc_gfx_BlendTarget_blend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blend_set) + +static bool js_cc_gfx_BlendTarget_blend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blend, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blend_get) + +static bool js_cc_gfx_BlendTarget_blendSrc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendSrc_set) + +static bool js_cc_gfx_BlendTarget_blendSrc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendSrc_get) + +static bool js_cc_gfx_BlendTarget_blendDst_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDst, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendDst_set) + +static bool js_cc_gfx_BlendTarget_blendDst_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDst, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDst, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendDst_get) + +static bool js_cc_gfx_BlendTarget_blendEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendEq_set) + +static bool js_cc_gfx_BlendTarget_blendEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendEq_get) + +static bool js_cc_gfx_BlendTarget_blendSrcAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrcAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendSrcAlpha_set) + +static bool js_cc_gfx_BlendTarget_blendSrcAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrcAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrcAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendSrcAlpha_get) + +static bool js_cc_gfx_BlendTarget_blendDstAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDstAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendDstAlpha_set) + +static bool js_cc_gfx_BlendTarget_blendDstAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDstAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDstAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendDstAlpha_get) + +static bool js_cc_gfx_BlendTarget_blendAlphaEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendAlphaEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendAlphaEq_set) + +static bool js_cc_gfx_BlendTarget_blendAlphaEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendAlphaEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendAlphaEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendAlphaEq_get) + +static bool js_cc_gfx_BlendTarget_blendColorMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColorMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendColorMask_set) + +static bool js_cc_gfx_BlendTarget_blendColorMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColorMask, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColorMask, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendColorMask_get) + +static bool js_cc_gfx_BlendTarget_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendTarget_reset) + +static bool js_cc_gfx_BlendTarget_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + cc::gfx::BlendTarget *arg2 = 0 ; + cc::gfx::BlendTarget temp2 ; + cc::gfx::BlendTarget *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(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::gfx::BlendTarget *) &(arg1)->copy((cc::gfx::BlendTarget 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_gfx_BlendTarget_copy) + +static bool js_new_cc_gfx_BlendTarget(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BlendTarget *result; + result = (cc::gfx::BlendTarget *)new cc::gfx::BlendTarget(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BlendTarget, __jsb_cc_gfx_BlendTarget_class, js_delete_cc_gfx_BlendTarget) + +static bool js_delete_cc_gfx_BlendTarget(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BlendTarget) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendTarget * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("blend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blend), ctx); + } + + + json->getProperty("blendSrc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrc), ctx); + } + + + json->getProperty("blendDst", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDst), ctx); + } + + + json->getProperty("blendEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendEq), ctx); + } + + + json->getProperty("blendSrcAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrcAlpha), ctx); + } + + + json->getProperty("blendDstAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDstAlpha), ctx); + } + + + json->getProperty("blendAlphaEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendAlphaEq), ctx); + } + + + json->getProperty("blendColorMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColorMask), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BlendTarget(se::Object* obj) { + auto* cls = se::Class::create("BlendTarget", obj, nullptr, _SE(js_new_cc_gfx_BlendTarget)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("blend", _SE(js_cc_gfx_BlendTarget_blend_get), _SE(js_cc_gfx_BlendTarget_blend_set)); + cls->defineProperty("blendSrc", _SE(js_cc_gfx_BlendTarget_blendSrc_get), _SE(js_cc_gfx_BlendTarget_blendSrc_set)); + cls->defineProperty("blendDst", _SE(js_cc_gfx_BlendTarget_blendDst_get), _SE(js_cc_gfx_BlendTarget_blendDst_set)); + cls->defineProperty("blendEq", _SE(js_cc_gfx_BlendTarget_blendEq_get), _SE(js_cc_gfx_BlendTarget_blendEq_set)); + cls->defineProperty("blendSrcAlpha", _SE(js_cc_gfx_BlendTarget_blendSrcAlpha_get), _SE(js_cc_gfx_BlendTarget_blendSrcAlpha_set)); + cls->defineProperty("blendDstAlpha", _SE(js_cc_gfx_BlendTarget_blendDstAlpha_get), _SE(js_cc_gfx_BlendTarget_blendDstAlpha_set)); + cls->defineProperty("blendAlphaEq", _SE(js_cc_gfx_BlendTarget_blendAlphaEq_get), _SE(js_cc_gfx_BlendTarget_blendAlphaEq_set)); + cls->defineProperty("blendColorMask", _SE(js_cc_gfx_BlendTarget_blendColorMask_get), _SE(js_cc_gfx_BlendTarget_blendColorMask_set)); + + cls->defineFunction("reset", _SE(js_cc_gfx_BlendTarget_reset)); + cls->defineFunction("copy", _SE(js_cc_gfx_BlendTarget_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BlendTarget)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BlendTarget_proto = cls->getProto(); + __jsb_cc_gfx_BlendTarget_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BlendState_class = nullptr; +se::Object* __jsb_cc_gfx_BlendState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BlendState) + +static bool js_cc_gfx_BlendState_isA2C_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isA2C, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_isA2C_set) + +static bool js_cc_gfx_BlendState_isA2C_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isA2C, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_isA2C_get) + +static bool js_cc_gfx_BlendState_isIndepend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isIndepend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_isIndepend_set) + +static bool js_cc_gfx_BlendState_isIndepend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isIndepend, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_isIndepend_get) + +static bool js_cc_gfx_BlendState_blendColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_blendColor_set) + +static bool js_cc_gfx_BlendState_blendColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_blendColor_get) + +static bool js_cc_gfx_BlendState_targets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_targets_set) + +static bool js_cc_gfx_BlendState_targets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targets, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targets, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_targets_get) + +static bool js_cc_gfx_BlendState_setTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + index_t arg2 ; + cc::gfx::BlendTarget *arg3 = 0 ; + cc::gfx::BlendTarget temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTarget(arg2,(cc::gfx::BlendTarget const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendState_setTarget) + +static bool js_cc_gfx_BlendState_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendState_reset) + +static bool js_cc_gfx_BlendState_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendState_destroy) + +static bool js_cc_gfx_BlendState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + cc::gfx::BlendState *arg2 = 0 ; + cc::gfx::BlendState temp2 ; + cc::gfx::BlendState *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(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::gfx::BlendState *) &(arg1)->copy((cc::gfx::BlendState 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_gfx_BlendState_copy) + +static bool js_new_cc_gfx_BlendState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BlendState *result; + result = (cc::gfx::BlendState *)new cc::gfx::BlendState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BlendState, __jsb_cc_gfx_BlendState_class, js_delete_cc_gfx_BlendState) + +static bool js_delete_cc_gfx_BlendState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BlendState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isA2C", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isA2C), ctx); + } + + + json->getProperty("isIndepend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isIndepend), ctx); + } + + + json->getProperty("blendColor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColor), ctx); + } + + + json->getProperty("targets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targets), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BlendState(se::Object* obj) { + auto* cls = se::Class::create("BlendState", obj, nullptr, _SE(js_new_cc_gfx_BlendState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isA2C", _SE(js_cc_gfx_BlendState_isA2C_get), _SE(js_cc_gfx_BlendState_isA2C_set)); + cls->defineProperty("isIndepend", _SE(js_cc_gfx_BlendState_isIndepend_get), _SE(js_cc_gfx_BlendState_isIndepend_set)); + cls->defineProperty("blendColor", _SE(js_cc_gfx_BlendState_blendColor_get), _SE(js_cc_gfx_BlendState_blendColor_set)); + cls->defineProperty("targets", _SE(js_cc_gfx_BlendState_targets_get), _SE(js_cc_gfx_BlendState_targets_set)); + + cls->defineFunction("setTarget", _SE(js_cc_gfx_BlendState_setTarget)); + cls->defineFunction("reset", _SE(js_cc_gfx_BlendState_reset)); + cls->defineFunction("destroy", _SE(js_cc_gfx_BlendState_destroy)); + cls->defineFunction("copy", _SE(js_cc_gfx_BlendState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BlendState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BlendState_proto = cls->getProto(); + __jsb_cc_gfx_BlendState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineStateInfo_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineStateInfo) + +static bool js_cc_gfx_PipelineStateInfo_shader_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shader, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_shader_set) + +static bool js_cc_gfx_PipelineStateInfo_shader_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shader, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shader, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_shader_get) + +static bool js_cc_gfx_PipelineStateInfo_pipelineLayout_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pipelineLayout, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_pipelineLayout_set) + +static bool js_cc_gfx_PipelineStateInfo_pipelineLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pipelineLayout, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pipelineLayout, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_pipelineLayout_get) + +static bool js_cc_gfx_PipelineStateInfo_renderPass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_renderPass_set) + +static bool js_cc_gfx_PipelineStateInfo_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPass, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderPass, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_renderPass_get) + +static bool js_cc_gfx_PipelineStateInfo_inputState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inputState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_inputState_set) + +static bool js_cc_gfx_PipelineStateInfo_inputState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inputState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->inputState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_inputState_get) + +static bool js_cc_gfx_PipelineStateInfo_rasterizerState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rasterizerState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_rasterizerState_set) + +static bool js_cc_gfx_PipelineStateInfo_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rasterizerState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rasterizerState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_rasterizerState_get) + +static bool js_cc_gfx_PipelineStateInfo_depthStencilState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_depthStencilState_set) + +static bool js_cc_gfx_PipelineStateInfo_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_depthStencilState_get) + +static bool js_cc_gfx_PipelineStateInfo_blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_blendState_set) + +static bool js_cc_gfx_PipelineStateInfo_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_blendState_get) + +static bool js_cc_gfx_PipelineStateInfo_primitive_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitive, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_primitive_set) + +static bool js_cc_gfx_PipelineStateInfo_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitive, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitive, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_primitive_get) + +static bool js_cc_gfx_PipelineStateInfo_dynamicStates_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamicStates, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_dynamicStates_set) + +static bool js_cc_gfx_PipelineStateInfo_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamicStates, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamicStates, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_dynamicStates_get) + +static bool js_cc_gfx_PipelineStateInfo_bindPoint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindPoint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_bindPoint_set) + +static bool js_cc_gfx_PipelineStateInfo_bindPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindPoint, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindPoint, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_bindPoint_get) + +static bool js_cc_gfx_PipelineStateInfo_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_subpass_set) + +static bool js_cc_gfx_PipelineStateInfo_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_subpass_get) + +static bool js_cc_gfx_PipelineStateInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + cc::gfx::PipelineStateInfo *arg2 = 0 ; + cc::gfx::PipelineStateInfo temp2 ; + cc::gfx::PipelineStateInfo *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(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::gfx::PipelineStateInfo *) &(arg1)->copy((cc::gfx::PipelineStateInfo 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_gfx_PipelineStateInfo_copy) + +static bool js_new_cc_gfx_PipelineStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::PipelineStateInfo *result; + result = (cc::gfx::PipelineStateInfo *)new cc::gfx::PipelineStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_PipelineStateInfo, __jsb_cc_gfx_PipelineStateInfo_class, js_delete_cc_gfx_PipelineStateInfo) + +static bool js_delete_cc_gfx_PipelineStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("shader", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shader), ctx); + } + + + json->getProperty("pipelineLayout", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pipelineLayout), ctx); + } + + + json->getProperty("renderPass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPass), ctx); + } + + + json->getProperty("inputState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->inputState), ctx); + } + + + json->getProperty("rasterizerState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rasterizerState), ctx); + } + + + json->getProperty("depthStencilState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilState), ctx); + } + + + json->getProperty("blendState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendState), ctx); + } + + + json->getProperty("primitive", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitive), ctx); + } + + + json->getProperty("dynamicStates", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamicStates), ctx); + } + + + json->getProperty("bindPoint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindPoint), ctx); + } + + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_PipelineStateInfo(se::Object* obj) { + auto* cls = se::Class::create("PipelineStateInfo", obj, nullptr, _SE(js_new_cc_gfx_PipelineStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("shader", _SE(js_cc_gfx_PipelineStateInfo_shader_get), _SE(js_cc_gfx_PipelineStateInfo_shader_set)); + cls->defineProperty("pipelineLayout", _SE(js_cc_gfx_PipelineStateInfo_pipelineLayout_get), _SE(js_cc_gfx_PipelineStateInfo_pipelineLayout_set)); + cls->defineProperty("renderPass", _SE(js_cc_gfx_PipelineStateInfo_renderPass_get), _SE(js_cc_gfx_PipelineStateInfo_renderPass_set)); + cls->defineProperty("inputState", _SE(js_cc_gfx_PipelineStateInfo_inputState_get), _SE(js_cc_gfx_PipelineStateInfo_inputState_set)); + cls->defineProperty("rasterizerState", _SE(js_cc_gfx_PipelineStateInfo_rasterizerState_get), _SE(js_cc_gfx_PipelineStateInfo_rasterizerState_set)); + cls->defineProperty("depthStencilState", _SE(js_cc_gfx_PipelineStateInfo_depthStencilState_get), _SE(js_cc_gfx_PipelineStateInfo_depthStencilState_set)); + cls->defineProperty("blendState", _SE(js_cc_gfx_PipelineStateInfo_blendState_get), _SE(js_cc_gfx_PipelineStateInfo_blendState_set)); + cls->defineProperty("primitive", _SE(js_cc_gfx_PipelineStateInfo_primitive_get), _SE(js_cc_gfx_PipelineStateInfo_primitive_set)); + cls->defineProperty("dynamicStates", _SE(js_cc_gfx_PipelineStateInfo_dynamicStates_get), _SE(js_cc_gfx_PipelineStateInfo_dynamicStates_set)); + cls->defineProperty("bindPoint", _SE(js_cc_gfx_PipelineStateInfo_bindPoint_get), _SE(js_cc_gfx_PipelineStateInfo_bindPoint_set)); + cls->defineProperty("subpass", _SE(js_cc_gfx_PipelineStateInfo_subpass_get), _SE(js_cc_gfx_PipelineStateInfo_subpass_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_PipelineStateInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineStateInfo_proto = cls->getProto(); + __jsb_cc_gfx_PipelineStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_CommandBufferInfo_class = nullptr; +se::Object* __jsb_cc_gfx_CommandBufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_CommandBufferInfo) + +static bool js_cc_gfx_CommandBufferInfo_queue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->queue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_CommandBufferInfo_queue_set) + +static bool js_cc_gfx_CommandBufferInfo_queue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->queue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->queue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBufferInfo_queue_get) + +static bool js_cc_gfx_CommandBufferInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_CommandBufferInfo_type_set) + +static bool js_cc_gfx_CommandBufferInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBufferInfo_type_get) + +static bool js_cc_gfx_CommandBufferInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + cc::gfx::CommandBufferInfo *arg2 = 0 ; + cc::gfx::CommandBufferInfo temp2 ; + cc::gfx::CommandBufferInfo *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(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::gfx::CommandBufferInfo *) &(arg1)->copy((cc::gfx::CommandBufferInfo 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_gfx_CommandBufferInfo_copy) + +static bool js_new_cc_gfx_CommandBufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::CommandBufferInfo *result; + result = (cc::gfx::CommandBufferInfo *)new cc::gfx::CommandBufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_CommandBufferInfo, __jsb_cc_gfx_CommandBufferInfo_class, js_delete_cc_gfx_CommandBufferInfo) + +static bool js_delete_cc_gfx_CommandBufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_CommandBufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::CommandBufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("queue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->queue), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_CommandBufferInfo(se::Object* obj) { + auto* cls = se::Class::create("CommandBufferInfo", obj, nullptr, _SE(js_new_cc_gfx_CommandBufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("queue", _SE(js_cc_gfx_CommandBufferInfo_queue_get), _SE(js_cc_gfx_CommandBufferInfo_queue_set)); + cls->defineProperty("type", _SE(js_cc_gfx_CommandBufferInfo_type_get), _SE(js_cc_gfx_CommandBufferInfo_type_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_CommandBufferInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_CommandBufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_CommandBufferInfo_proto = cls->getProto(); + __jsb_cc_gfx_CommandBufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_QueueInfo_class = nullptr; +se::Object* __jsb_cc_gfx_QueueInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_QueueInfo) + +static bool js_cc_gfx_QueueInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueueInfo *arg1 = (cc::gfx::QueueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueueInfo_type_set) + +static bool js_cc_gfx_QueueInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueueInfo *arg1 = (cc::gfx::QueueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueueInfo_type_get) + +static bool js_cc_gfx_QueueInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueueInfo *arg1 = (cc::gfx::QueueInfo *) NULL ; + cc::gfx::QueueInfo *arg2 = 0 ; + cc::gfx::QueueInfo temp2 ; + cc::gfx::QueueInfo *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(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::gfx::QueueInfo *) &(arg1)->copy((cc::gfx::QueueInfo 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_gfx_QueueInfo_copy) + +static bool js_new_cc_gfx_QueueInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::QueueInfo *result; + result = (cc::gfx::QueueInfo *)new cc::gfx::QueueInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_QueueInfo, __jsb_cc_gfx_QueueInfo_class, js_delete_cc_gfx_QueueInfo) + +static bool js_delete_cc_gfx_QueueInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_QueueInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueueInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_QueueInfo(se::Object* obj) { + auto* cls = se::Class::create("QueueInfo", obj, nullptr, _SE(js_new_cc_gfx_QueueInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_QueueInfo_type_get), _SE(js_cc_gfx_QueueInfo_type_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_QueueInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_QueueInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_QueueInfo_proto = cls->getProto(); + __jsb_cc_gfx_QueueInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_QueryPoolInfo_class = nullptr; +se::Object* __jsb_cc_gfx_QueryPoolInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_QueryPoolInfo) + +static bool js_cc_gfx_QueryPoolInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueryPoolInfo_type_set) + +static bool js_cc_gfx_QueryPoolInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueryPoolInfo_type_get) + +static bool js_cc_gfx_QueryPoolInfo_maxQueryObjects_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxQueryObjects, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueryPoolInfo_maxQueryObjects_set) + +static bool js_cc_gfx_QueryPoolInfo_maxQueryObjects_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxQueryObjects, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueryPoolInfo_maxQueryObjects_get) + +static bool js_cc_gfx_QueryPoolInfo_forceWait_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->forceWait); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueryPoolInfo_forceWait_set) + +static bool js_cc_gfx_QueryPoolInfo_forceWait_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->forceWait, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueryPoolInfo_forceWait_get) + +static bool js_cc_gfx_QueryPoolInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + cc::gfx::QueryPoolInfo *arg2 = 0 ; + cc::gfx::QueryPoolInfo temp2 ; + cc::gfx::QueryPoolInfo *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(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::gfx::QueryPoolInfo *) &(arg1)->copy((cc::gfx::QueryPoolInfo 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_gfx_QueryPoolInfo_copy) + +static bool js_new_cc_gfx_QueryPoolInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::QueryPoolInfo *result; + result = (cc::gfx::QueryPoolInfo *)new cc::gfx::QueryPoolInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_QueryPoolInfo, __jsb_cc_gfx_QueryPoolInfo_class, js_delete_cc_gfx_QueryPoolInfo) + +static bool js_delete_cc_gfx_QueryPoolInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_QueryPoolInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueryPoolInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("maxQueryObjects", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxQueryObjects), ctx); + } + + + json->getProperty("forceWait", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->forceWait), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_QueryPoolInfo(se::Object* obj) { + auto* cls = se::Class::create("QueryPoolInfo", obj, nullptr, _SE(js_new_cc_gfx_QueryPoolInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_QueryPoolInfo_type_get), _SE(js_cc_gfx_QueryPoolInfo_type_set)); + cls->defineProperty("maxQueryObjects", _SE(js_cc_gfx_QueryPoolInfo_maxQueryObjects_get), _SE(js_cc_gfx_QueryPoolInfo_maxQueryObjects_set)); + cls->defineProperty("forceWait", _SE(js_cc_gfx_QueryPoolInfo_forceWait_get), _SE(js_cc_gfx_QueryPoolInfo_forceWait_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_QueryPoolInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_QueryPoolInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_QueryPoolInfo_proto = cls->getProto(); + __jsb_cc_gfx_QueryPoolInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_FormatInfo_class = nullptr; +se::Object* __jsb_cc_gfx_FormatInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_FormatInfo) + +static bool js_cc_gfx_FormatInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_name_set) + +static bool js_cc_gfx_FormatInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_name_get) + +static bool js_cc_gfx_FormatInfo_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_size_set) + +static bool js_cc_gfx_FormatInfo_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_size_get) + +static bool js_cc_gfx_FormatInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_count_set) + +static bool js_cc_gfx_FormatInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_count_get) + +static bool js_cc_gfx_FormatInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_type_set) + +static bool js_cc_gfx_FormatInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_type_get) + +static bool js_cc_gfx_FormatInfo_hasAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hasAlpha); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_hasAlpha_set) + +static bool js_cc_gfx_FormatInfo_hasAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hasAlpha, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_hasAlpha_get) + +static bool js_cc_gfx_FormatInfo_hasDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hasDepth); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_hasDepth_set) + +static bool js_cc_gfx_FormatInfo_hasDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hasDepth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_hasDepth_get) + +static bool js_cc_gfx_FormatInfo_hasStencil_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hasStencil); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_hasStencil_set) + +static bool js_cc_gfx_FormatInfo_hasStencil_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hasStencil, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_hasStencil_get) + +static bool js_cc_gfx_FormatInfo_isCompressed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isCompressed); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_isCompressed_set) + +static bool js_cc_gfx_FormatInfo_isCompressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isCompressed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_isCompressed_get) + +static bool js_new_cc_gfx_FormatInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::FormatInfo *result; + result = (cc::gfx::FormatInfo *)new cc::gfx::FormatInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_FormatInfo, __jsb_cc_gfx_FormatInfo_class, js_delete_cc_gfx_FormatInfo) + +static bool js_delete_cc_gfx_FormatInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_FormatInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FormatInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("hasAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hasAlpha), ctx); + } + + + json->getProperty("hasDepth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hasDepth), ctx); + } + + + json->getProperty("hasStencil", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hasStencil), ctx); + } + + + json->getProperty("isCompressed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isCompressed), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_FormatInfo(se::Object* obj) { + auto* cls = se::Class::create("FormatInfo", obj, nullptr, _SE(js_new_cc_gfx_FormatInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_FormatInfo_name_get), _SE(js_cc_gfx_FormatInfo_name_set)); + cls->defineProperty("size", _SE(js_cc_gfx_FormatInfo_size_get), _SE(js_cc_gfx_FormatInfo_size_set)); + cls->defineProperty("count", _SE(js_cc_gfx_FormatInfo_count_get), _SE(js_cc_gfx_FormatInfo_count_set)); + cls->defineProperty("type", _SE(js_cc_gfx_FormatInfo_type_get), _SE(js_cc_gfx_FormatInfo_type_set)); + cls->defineProperty("hasAlpha", _SE(js_cc_gfx_FormatInfo_hasAlpha_get), _SE(js_cc_gfx_FormatInfo_hasAlpha_set)); + cls->defineProperty("hasDepth", _SE(js_cc_gfx_FormatInfo_hasDepth_get), _SE(js_cc_gfx_FormatInfo_hasDepth_set)); + cls->defineProperty("hasStencil", _SE(js_cc_gfx_FormatInfo_hasStencil_get), _SE(js_cc_gfx_FormatInfo_hasStencil_set)); + cls->defineProperty("isCompressed", _SE(js_cc_gfx_FormatInfo_isCompressed_get), _SE(js_cc_gfx_FormatInfo_isCompressed_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_FormatInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_FormatInfo_proto = cls->getProto(); + __jsb_cc_gfx_FormatInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_MemoryStatus_class = nullptr; +se::Object* __jsb_cc_gfx_MemoryStatus_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_MemoryStatus) + +static bool js_cc_gfx_MemoryStatus_bufferSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bufferSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MemoryStatus_bufferSize_set) + +static bool js_cc_gfx_MemoryStatus_bufferSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bufferSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MemoryStatus_bufferSize_get) + +static bool js_cc_gfx_MemoryStatus_textureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MemoryStatus_textureSize_set) + +static bool js_cc_gfx_MemoryStatus_textureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MemoryStatus_textureSize_get) + +static bool js_cc_gfx_MemoryStatus_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + cc::gfx::MemoryStatus *arg2 = 0 ; + cc::gfx::MemoryStatus temp2 ; + cc::gfx::MemoryStatus *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(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::gfx::MemoryStatus *) &(arg1)->copy((cc::gfx::MemoryStatus 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_gfx_MemoryStatus_copy) + +static bool js_new_cc_gfx_MemoryStatus(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::MemoryStatus *result; + result = (cc::gfx::MemoryStatus *)new cc::gfx::MemoryStatus(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_MemoryStatus, __jsb_cc_gfx_MemoryStatus_class, js_delete_cc_gfx_MemoryStatus) + +static bool js_delete_cc_gfx_MemoryStatus(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_MemoryStatus) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MemoryStatus * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bufferSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bufferSize), ctx); + } + + + json->getProperty("textureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textureSize), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_MemoryStatus(se::Object* obj) { + auto* cls = se::Class::create("MemoryStatus", obj, nullptr, _SE(js_new_cc_gfx_MemoryStatus)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bufferSize", _SE(js_cc_gfx_MemoryStatus_bufferSize_get), _SE(js_cc_gfx_MemoryStatus_bufferSize_set)); + cls->defineProperty("textureSize", _SE(js_cc_gfx_MemoryStatus_textureSize_get), _SE(js_cc_gfx_MemoryStatus_textureSize_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_MemoryStatus_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_MemoryStatus)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_MemoryStatus_proto = cls->getProto(); + __jsb_cc_gfx_MemoryStatus_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DynamicStencilStates_class = nullptr; +se::Object* __jsb_cc_gfx_DynamicStencilStates_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStencilStates) + +static bool js_cc_gfx_DynamicStencilStates_writeMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->writeMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStencilStates_writeMask_set) + +static bool js_cc_gfx_DynamicStencilStates_writeMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->writeMask, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStencilStates_writeMask_get) + +static bool js_cc_gfx_DynamicStencilStates_compareMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compareMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStencilStates_compareMask_set) + +static bool js_cc_gfx_DynamicStencilStates_compareMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compareMask, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStencilStates_compareMask_get) + +static bool js_cc_gfx_DynamicStencilStates_reference_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reference, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStencilStates_reference_set) + +static bool js_cc_gfx_DynamicStencilStates_reference_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reference, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStencilStates_reference_get) + +static bool js_cc_gfx_DynamicStencilStates_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + cc::gfx::DynamicStencilStates *arg2 = 0 ; + cc::gfx::DynamicStencilStates temp2 ; + cc::gfx::DynamicStencilStates *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(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::gfx::DynamicStencilStates *) &(arg1)->copy((cc::gfx::DynamicStencilStates 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_gfx_DynamicStencilStates_copy) + +static bool js_new_cc_gfx_DynamicStencilStates(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DynamicStencilStates *result; + result = (cc::gfx::DynamicStencilStates *)new cc::gfx::DynamicStencilStates(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DynamicStencilStates, __jsb_cc_gfx_DynamicStencilStates_class, js_delete_cc_gfx_DynamicStencilStates) + +static bool js_delete_cc_gfx_DynamicStencilStates(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStencilStates) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStencilStates * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("writeMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->writeMask), ctx); + } + + + json->getProperty("compareMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compareMask), ctx); + } + + + json->getProperty("reference", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reference), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DynamicStencilStates(se::Object* obj) { + auto* cls = se::Class::create("DynamicStencilStates", obj, nullptr, _SE(js_new_cc_gfx_DynamicStencilStates)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("writeMask", _SE(js_cc_gfx_DynamicStencilStates_writeMask_get), _SE(js_cc_gfx_DynamicStencilStates_writeMask_set)); + cls->defineProperty("compareMask", _SE(js_cc_gfx_DynamicStencilStates_compareMask_get), _SE(js_cc_gfx_DynamicStencilStates_compareMask_set)); + cls->defineProperty("reference", _SE(js_cc_gfx_DynamicStencilStates_reference_get), _SE(js_cc_gfx_DynamicStencilStates_reference_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DynamicStencilStates_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DynamicStencilStates)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DynamicStencilStates_proto = cls->getProto(); + __jsb_cc_gfx_DynamicStencilStates_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DynamicStates_class = nullptr; +se::Object* __jsb_cc_gfx_DynamicStates_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStates) + +static bool js_cc_gfx_DynamicStates_viewport_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->viewport, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_viewport_set) + +static bool js_cc_gfx_DynamicStates_viewport_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->viewport, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->viewport, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_viewport_get) + +static bool js_cc_gfx_DynamicStates_scissor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scissor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_scissor_set) + +static bool js_cc_gfx_DynamicStates_scissor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scissor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->scissor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_scissor_get) + +static bool js_cc_gfx_DynamicStates_blendConstant_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendConstant, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_blendConstant_set) + +static bool js_cc_gfx_DynamicStates_blendConstant_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendConstant, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendConstant, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_blendConstant_get) + +static bool js_cc_gfx_DynamicStates_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_lineWidth_set) + +static bool js_cc_gfx_DynamicStates_lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lineWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_lineWidth_get) + +static bool js_cc_gfx_DynamicStates_depthBiasConstant_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasConstant, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthBiasConstant_set) + +static bool js_cc_gfx_DynamicStates_depthBiasConstant_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasConstant, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthBiasConstant_get) + +static bool js_cc_gfx_DynamicStates_depthBiasClamp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasClamp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthBiasClamp_set) + +static bool js_cc_gfx_DynamicStates_depthBiasClamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasClamp, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthBiasClamp_get) + +static bool js_cc_gfx_DynamicStates_depthBiasSlope_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasSlope, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthBiasSlope_set) + +static bool js_cc_gfx_DynamicStates_depthBiasSlope_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasSlope, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthBiasSlope_get) + +static bool js_cc_gfx_DynamicStates_depthMinBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthMinBounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthMinBounds_set) + +static bool js_cc_gfx_DynamicStates_depthMinBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthMinBounds, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthMinBounds_get) + +static bool js_cc_gfx_DynamicStates_depthMaxBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthMaxBounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthMaxBounds_set) + +static bool js_cc_gfx_DynamicStates_depthMaxBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthMaxBounds, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthMaxBounds_get) + +static bool js_cc_gfx_DynamicStates_stencilStatesFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilStatesFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_stencilStatesFront_set) + +static bool js_cc_gfx_DynamicStates_stencilStatesFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilStatesFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilStatesFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_stencilStatesFront_get) + +static bool js_cc_gfx_DynamicStates_stencilStatesBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilStatesBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_stencilStatesBack_set) + +static bool js_cc_gfx_DynamicStates_stencilStatesBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilStatesBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilStatesBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_stencilStatesBack_get) + +static bool js_cc_gfx_DynamicStates_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + cc::gfx::DynamicStates *arg2 = 0 ; + cc::gfx::DynamicStates temp2 ; + cc::gfx::DynamicStates *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(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::gfx::DynamicStates *) &(arg1)->copy((cc::gfx::DynamicStates 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_gfx_DynamicStates_copy) + +static bool js_new_cc_gfx_DynamicStates(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DynamicStates *result; + result = (cc::gfx::DynamicStates *)new cc::gfx::DynamicStates(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DynamicStates, __jsb_cc_gfx_DynamicStates_class, js_delete_cc_gfx_DynamicStates) + +static bool js_delete_cc_gfx_DynamicStates(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStates) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStates * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("viewport", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->viewport), ctx); + } + + + json->getProperty("scissor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->scissor), ctx); + } + + + json->getProperty("blendConstant", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendConstant), ctx); + } + + + json->getProperty("lineWidth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lineWidth), ctx); + } + + + json->getProperty("depthBiasConstant", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasConstant), ctx); + } + + + json->getProperty("depthBiasClamp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasClamp), ctx); + } + + + json->getProperty("depthBiasSlope", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasSlope), ctx); + } + + + json->getProperty("depthMinBounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthMinBounds), ctx); + } + + + json->getProperty("depthMaxBounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthMaxBounds), ctx); + } + + + json->getProperty("stencilStatesFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilStatesFront), ctx); + } + + + json->getProperty("stencilStatesBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilStatesBack), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DynamicStates(se::Object* obj) { + auto* cls = se::Class::create("DynamicStates", obj, nullptr, _SE(js_new_cc_gfx_DynamicStates)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("viewport", _SE(js_cc_gfx_DynamicStates_viewport_get), _SE(js_cc_gfx_DynamicStates_viewport_set)); + cls->defineProperty("scissor", _SE(js_cc_gfx_DynamicStates_scissor_get), _SE(js_cc_gfx_DynamicStates_scissor_set)); + cls->defineProperty("blendConstant", _SE(js_cc_gfx_DynamicStates_blendConstant_get), _SE(js_cc_gfx_DynamicStates_blendConstant_set)); + cls->defineProperty("lineWidth", _SE(js_cc_gfx_DynamicStates_lineWidth_get), _SE(js_cc_gfx_DynamicStates_lineWidth_set)); + cls->defineProperty("depthBiasConstant", _SE(js_cc_gfx_DynamicStates_depthBiasConstant_get), _SE(js_cc_gfx_DynamicStates_depthBiasConstant_set)); + cls->defineProperty("depthBiasClamp", _SE(js_cc_gfx_DynamicStates_depthBiasClamp_get), _SE(js_cc_gfx_DynamicStates_depthBiasClamp_set)); + cls->defineProperty("depthBiasSlope", _SE(js_cc_gfx_DynamicStates_depthBiasSlope_get), _SE(js_cc_gfx_DynamicStates_depthBiasSlope_set)); + cls->defineProperty("depthMinBounds", _SE(js_cc_gfx_DynamicStates_depthMinBounds_get), _SE(js_cc_gfx_DynamicStates_depthMinBounds_set)); + cls->defineProperty("depthMaxBounds", _SE(js_cc_gfx_DynamicStates_depthMaxBounds_get), _SE(js_cc_gfx_DynamicStates_depthMaxBounds_set)); + cls->defineProperty("stencilStatesFront", _SE(js_cc_gfx_DynamicStates_stencilStatesFront_get), _SE(js_cc_gfx_DynamicStates_stencilStatesFront_set)); + cls->defineProperty("stencilStatesBack", _SE(js_cc_gfx_DynamicStates_stencilStatesBack_get), _SE(js_cc_gfx_DynamicStates_stencilStatesBack_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DynamicStates_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DynamicStates)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DynamicStates_proto = cls->getProto(); + __jsb_cc_gfx_DynamicStates_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_GFXObject_class = nullptr; +se::Object* __jsb_cc_gfx_GFXObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_GFXObject) + +static bool js_new_cc_gfx_GFXObject(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::ObjectType arg1 ; + cc::gfx::GFXObject *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::GFXObject *)new cc::gfx::GFXObject(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_GFXObject, __jsb_cc_gfx_GFXObject_class, js_delete_cc_gfx_GFXObject) + +static bool js_delete_cc_gfx_GFXObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_GFXObject) + +static bool js_cc_gfx_GFXObject_getObjectID_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::gfx::GFXObject::getObjectID((cc::gfx::GFXObject const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_GFXObject_getObjectID_static) + +static bool js_cc_gfx_GFXObject_objectType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + cc::gfx::ObjectType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::ObjectType)cc_gfx_GFXObject_objectType_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_gfx_GFXObject_objectType_get) + +static bool js_cc_gfx_GFXObject_objectID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_GFXObject_objectID_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GFXObject_objectID_get) + +static bool js_cc_gfx_GFXObject_typedID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_GFXObject_typedID_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GFXObject_typedID_get) + +bool js_register_cc_gfx_GFXObject(se::Object* obj) { + auto* cls = se::Class::create("GFXObject", obj, nullptr, _SE(js_new_cc_gfx_GFXObject)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("objectType", _SE(js_cc_gfx_GFXObject_objectType_get), nullptr); + cls->defineProperty("objectID", _SE(js_cc_gfx_GFXObject_objectID_get), nullptr); + cls->defineProperty("typedID", _SE(js_cc_gfx_GFXObject_typedID_get), nullptr); + + + + cls->defineStaticFunction("getObjectID", _SE(js_cc_gfx_GFXObject_getObjectID_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_GFXObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_GFXObject_proto = cls->getProto(); + __jsb_cc_gfx_GFXObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Buffer_class = nullptr; +se::Object* __jsb_cc_gfx_Buffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Buffer) + +static bool js_delete_cc_gfx_Buffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Buffer) + +static bool js_cc_gfx_Buffer_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = 0 ; + cc::gfx::BufferInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Buffer::computeHash((cc::gfx::BufferInfo const &)*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_FUNC(js_cc_gfx_Buffer_computeHash_static) + +static bool js_cc_gfx_Buffer_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Buffer_resize) + +static bool js_cc_gfx_Buffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Buffer_destroy) + +static bool js_cc_gfx_Buffer_isBufferView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gfx::Buffer const *)arg1)->isBufferView(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Buffer_isBufferView) + +static bool js_cc_gfx_Buffer_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferUsage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferUsage)cc_gfx_Buffer_usage_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_gfx_Buffer_usage_get) + +static bool js_cc_gfx_Buffer_memUsage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + cc::gfx::MemoryUsage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::MemoryUsage)cc_gfx_Buffer_memUsage_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_gfx_Buffer_memUsage_get) + +static bool js_cc_gfx_Buffer_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Buffer_stride_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Buffer_stride_get) + +static bool js_cc_gfx_Buffer_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Buffer_count_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Buffer_count_get) + +static bool js_cc_gfx_Buffer_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Buffer_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Buffer_size_get) + +static bool js_cc_gfx_Buffer_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferFlags result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferFlags)cc_gfx_Buffer_flags_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_gfx_Buffer_flags_get) + +bool js_register_cc_gfx_Buffer(se::Object* obj) { + auto* cls = se::Class::create("Buffer", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("usage", _SE(js_cc_gfx_Buffer_usage_get), nullptr); + cls->defineProperty("memUsage", _SE(js_cc_gfx_Buffer_memUsage_get), nullptr); + cls->defineProperty("stride", _SE(js_cc_gfx_Buffer_stride_get), nullptr); + cls->defineProperty("count", _SE(js_cc_gfx_Buffer_count_get), nullptr); + cls->defineProperty("size", _SE(js_cc_gfx_Buffer_size_get), nullptr); + cls->defineProperty("flags", _SE(js_cc_gfx_Buffer_flags_get), nullptr); + + cls->defineFunction("resize", _SE(js_cc_gfx_Buffer_resize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Buffer_destroy)); + cls->defineFunction("isBufferView", _SE(js_cc_gfx_Buffer_isBufferView)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Buffer_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Buffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Buffer_proto = cls->getProto(); + __jsb_cc_gfx_Buffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_CommandBuffer_class = nullptr; +se::Object* __jsb_cc_gfx_CommandBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_CommandBuffer) + +static bool js_delete_cc_gfx_CommandBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_CommandBuffer) + +static bool js_cc_gfx_CommandBuffer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::CommandBufferInfo *arg2 = 0 ; + cc::gfx::CommandBufferInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::CommandBufferInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_initialize) + +static bool js_cc_gfx_CommandBuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_destroy) + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + uint32_t arg3 ; + cc::gfx::Framebuffer *arg4 = (cc::gfx::Framebuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->begin(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_end(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->end(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_end) + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::Color *arg5 = (cc::gfx::Color *) NULL ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::CommandBuffer **arg8 = (cc::gfx::CommandBuffer **) NULL ; + uint32_t arg9 ; + cc::gfx::Rect temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::Color const *)arg5,arg6,arg7,(cc::gfx::CommandBuffer *const *)arg8,arg9); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_endRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endRenderPass(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_endRenderPass) + +static bool js_cc_gfx_CommandBuffer_insertMarker(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::MarkerInfo *arg2 = 0 ; + cc::gfx::MarkerInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->insertMarker((cc::gfx::MarkerInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_insertMarker) + +static bool js_cc_gfx_CommandBuffer_beginMarker(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::MarkerInfo *arg2 = 0 ; + cc::gfx::MarkerInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->beginMarker((cc::gfx::MarkerInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_beginMarker) + +static bool js_cc_gfx_CommandBuffer_endMarker(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endMarker(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_endMarker) + +static bool js_cc_gfx_CommandBuffer_bindPipelineState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::PipelineState *arg2 = (cc::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(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_gfx_CommandBuffer_bindPipelineState) + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg4 ; + uint32_t *arg5 = (uint32_t *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindDescriptorSet(arg2,arg3,arg4,(uint32_t const *)arg5); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_bindInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::InputAssembler *arg2 = (cc::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(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_gfx_CommandBuffer_bindInputAssembler) + +static bool js_cc_gfx_CommandBuffer_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Viewport *arg2 = 0 ; + cc::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(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((cc::gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setViewport) + +static bool js_cc_gfx_CommandBuffer_setScissor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Rect *arg2 = 0 ; + cc::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(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((cc::gfx::Rect const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setScissor) + +static bool js_cc_gfx_CommandBuffer_setLineWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLineWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setLineWidth) + +static bool js_cc_gfx_CommandBuffer_setDepthBias(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDepthBias(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setDepthBias) + +static bool js_cc_gfx_CommandBuffer_setBlendConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setBlendConstants((cc::gfx::Color const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setBlendConstants) + +static bool js_cc_gfx_CommandBuffer_setDepthBound(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDepthBound(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setDepthBound) + +static bool js_cc_gfx_CommandBuffer_setStencilWriteMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::StencilFace arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStencilWriteMask(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setStencilWriteMask) + +static bool js_cc_gfx_CommandBuffer_setStencilCompareMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::StencilFace arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStencilCompareMask(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setStencilCompareMask) + +static bool js_cc_gfx_CommandBuffer_nextSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->nextSubpass(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_nextSubpass) + +static bool js_cc_gfx_CommandBuffer_drawWithInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::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(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((cc::gfx::DrawInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_drawWithInfo) + +static bool js_cc_gfx_CommandBuffer_blitTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureBlit *arg4 = (cc::gfx::TextureBlit *) NULL ; + uint32_t arg5 ; + cc::gfx::Filter arg6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->blitTexture(arg2,arg3,(cc::gfx::TextureBlit const *)arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_copyTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureCopy *arg4 = (cc::gfx::TextureCopy *) NULL ; + uint32_t arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->copyTexture(arg2,arg3,(cc::gfx::TextureCopy const *)arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_copyTexture) + +static bool js_cc_gfx_CommandBuffer_dispatch(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::DispatchInfo *arg2 = 0 ; + cc::gfx::DispatchInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->dispatch((cc::gfx::DispatchInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_dispatch) + +static bool js_cc_gfx_CommandBuffer_beginQuery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->beginQuery(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_beginQuery) + +static bool js_cc_gfx_CommandBuffer_endQuery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->endQuery(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_endQuery) + +static bool js_cc_gfx_CommandBuffer_resetQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resetQueryPool(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_resetQueryPool) + +static bool js_cc_gfx_CommandBuffer_completeQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->completeQueryPool(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_completeQueryPool) + +static bool js_cc_gfx_CommandBuffer_customCommand(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::CommandBuffer::CustomCommand *arg2 = 0 ; + cc::gfx::CommandBuffer::CustomCommand temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->customCommand((cc::gfx::CommandBuffer::CustomCommand &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_customCommand) + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::GeneralBarrier *arg2 = (cc::gfx::GeneralBarrier *) NULL ; + cc::gfx::BufferBarrier **arg3 = (cc::gfx::BufferBarrier **) NULL ; + cc::gfx::Buffer **arg4 = (cc::gfx::Buffer **) NULL ; + uint32_t arg5 ; + cc::gfx::TextureBarrier **arg6 = (cc::gfx::TextureBarrier **) NULL ; + cc::gfx::Texture **arg7 = (cc::gfx::Texture **) NULL ; + uint32_t arg8 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->pipelineBarrier((cc::gfx::GeneralBarrier const *)arg2,(cc::gfx::BufferBarrier const *const *)arg3,(cc::gfx::Buffer const *const *)arg4,arg5,(cc::gfx::TextureBarrier const *const *)arg6,(cc::gfx::Texture const *const *)arg7,arg8); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->begin(); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->begin(arg2); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->begin(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_begin) + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindDescriptorSet(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + ccstd::vector< uint32_t > *arg4 = 0 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + (arg1)->bindDescriptorSet(arg2,arg3,(ccstd::vector< uint32_t > const &)*arg4); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_bindDescriptorSet) + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::ColorList *arg5 = 0 ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::CommandBufferList *arg8 = 0 ; + cc::gfx::Rect temp4 ; + cc::gfx::ColorList temp5 ; + cc::gfx::CommandBufferList temp8 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::ColorList const &)*arg5,arg6,arg7,(cc::gfx::CommandBufferList const &)*arg8); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::ColorList *arg5 = 0 ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::Rect temp4 ; + cc::gfx::ColorList temp5 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::ColorList const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::Color *arg5 = (cc::gfx::Color *) NULL ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::Rect temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::Color const *)arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_beginRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_beginRenderPass) + +static bool js_cc_gfx_CommandBuffer_draw(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::InputAssembler *arg2 = (cc::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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->draw(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_draw) + +static bool js_cc_gfx_CommandBuffer_blitTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureBlitList *arg4 = 0 ; + cc::gfx::Filter arg5 ; + cc::gfx::TextureBlitList temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->blitTexture(arg2,arg3,(cc::gfx::TextureBlitList const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_blitTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_gfx_CommandBuffer_blitTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_gfx_CommandBuffer_blitTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_blitTexture) + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::GeneralBarrier *arg2 = (cc::gfx::GeneralBarrier *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->pipelineBarrier((cc::gfx::GeneralBarrier const *)arg2); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::GeneralBarrier *arg2 = (cc::gfx::GeneralBarrier *) NULL ; + cc::gfx::BufferBarrierList *arg3 = 0 ; + cc::gfx::BufferList *arg4 = 0 ; + cc::gfx::TextureBarrierList *arg5 = 0 ; + cc::gfx::TextureList *arg6 = 0 ; + cc::gfx::BufferBarrierList temp3 ; + cc::gfx::BufferList temp4 ; + cc::gfx::TextureBarrierList temp5 ; + cc::gfx::TextureList temp6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->pipelineBarrier((cc::gfx::GeneralBarrier const *)arg2,(cc::gfx::BufferBarrierList const &)*arg3,(cc::gfx::BufferList const &)*arg4,(cc::gfx::TextureBarrierList const &)*arg5,(cc::gfx::TextureList const &)*arg6); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_pipelineBarrier) + +static bool js_cc_gfx_CommandBuffer_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::CommandBufferType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::CommandBufferType)cc_gfx_CommandBuffer_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_type_get) + +static bool js_cc_gfx_CommandBuffer_queue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Queue *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Queue *)cc_gfx_CommandBuffer_queue_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_gfx_CommandBuffer_queue_get) + +static bool js_cc_gfx_CommandBuffer_numDrawCalls_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_CommandBuffer_numDrawCalls_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_numDrawCalls_get) + +static bool js_cc_gfx_CommandBuffer_numInstances_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_CommandBuffer_numInstances_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_numInstances_get) + +static bool js_cc_gfx_CommandBuffer_numTris_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_CommandBuffer_numTris_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_numTris_get) + +bool js_register_cc_gfx_CommandBuffer(se::Object* obj) { + auto* cls = se::Class::create("CommandBuffer", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_CommandBuffer_type_get), nullptr); + cls->defineProperty("queue", _SE(js_cc_gfx_CommandBuffer_queue_get), nullptr); + cls->defineProperty("numDrawCalls", _SE(js_cc_gfx_CommandBuffer_numDrawCalls_get), nullptr); + cls->defineProperty("numInstances", _SE(js_cc_gfx_CommandBuffer_numInstances_get), nullptr); + cls->defineProperty("numTris", _SE(js_cc_gfx_CommandBuffer_numTris_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_CommandBuffer_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_CommandBuffer_destroy)); + cls->defineFunction("end", _SE(js_cc_gfx_CommandBuffer_end)); + cls->defineFunction("endRenderPass", _SE(js_cc_gfx_CommandBuffer_endRenderPass)); + cls->defineFunction("insertMarker", _SE(js_cc_gfx_CommandBuffer_insertMarker)); + cls->defineFunction("beginMarker", _SE(js_cc_gfx_CommandBuffer_beginMarker)); + cls->defineFunction("endMarker", _SE(js_cc_gfx_CommandBuffer_endMarker)); + cls->defineFunction("bindPipelineState", _SE(js_cc_gfx_CommandBuffer_bindPipelineState)); + cls->defineFunction("bindInputAssembler", _SE(js_cc_gfx_CommandBuffer_bindInputAssembler)); + cls->defineFunction("setViewport", _SE(js_cc_gfx_CommandBuffer_setViewport)); + cls->defineFunction("setScissor", _SE(js_cc_gfx_CommandBuffer_setScissor)); + cls->defineFunction("setLineWidth", _SE(js_cc_gfx_CommandBuffer_setLineWidth)); + cls->defineFunction("setDepthBias", _SE(js_cc_gfx_CommandBuffer_setDepthBias)); + cls->defineFunction("setBlendConstants", _SE(js_cc_gfx_CommandBuffer_setBlendConstants)); + cls->defineFunction("setDepthBound", _SE(js_cc_gfx_CommandBuffer_setDepthBound)); + cls->defineFunction("setStencilWriteMask", _SE(js_cc_gfx_CommandBuffer_setStencilWriteMask)); + cls->defineFunction("setStencilCompareMask", _SE(js_cc_gfx_CommandBuffer_setStencilCompareMask)); + cls->defineFunction("nextSubpass", _SE(js_cc_gfx_CommandBuffer_nextSubpass)); + cls->defineFunction("drawWithInfo", _SE(js_cc_gfx_CommandBuffer_drawWithInfo)); + cls->defineFunction("copyTexture", _SE(js_cc_gfx_CommandBuffer_copyTexture)); + cls->defineFunction("dispatch", _SE(js_cc_gfx_CommandBuffer_dispatch)); + cls->defineFunction("beginQuery", _SE(js_cc_gfx_CommandBuffer_beginQuery)); + cls->defineFunction("endQuery", _SE(js_cc_gfx_CommandBuffer_endQuery)); + cls->defineFunction("resetQueryPool", _SE(js_cc_gfx_CommandBuffer_resetQueryPool)); + cls->defineFunction("completeQueryPool", _SE(js_cc_gfx_CommandBuffer_completeQueryPool)); + cls->defineFunction("customCommand", _SE(js_cc_gfx_CommandBuffer_customCommand)); + cls->defineFunction("begin", _SE(js_cc_gfx_CommandBuffer_begin)); + cls->defineFunction("bindDescriptorSet", _SE(js_cc_gfx_CommandBuffer_bindDescriptorSet)); + cls->defineFunction("beginRenderPass", _SE(js_cc_gfx_CommandBuffer_beginRenderPass)); + cls->defineFunction("draw", _SE(js_cc_gfx_CommandBuffer_draw)); + cls->defineFunction("blitTexture", _SE(js_cc_gfx_CommandBuffer_blitTexture)); + cls->defineFunction("pipelineBarrier", _SE(js_cc_gfx_CommandBuffer_pipelineBarrier)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_CommandBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_CommandBuffer_proto = cls->getProto(); + __jsb_cc_gfx_CommandBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSet_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSet_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSet) + +static bool js_delete_cc_gfx_DescriptorSet(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSet) + +static bool js_cc_gfx_DescriptorSet_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + cc::gfx::DescriptorSetInfo *arg2 = 0 ; + cc::gfx::DescriptorSetInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::DescriptorSetInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_initialize) + +static bool js_cc_gfx_DescriptorSet_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_destroy) + +static bool js_cc_gfx_DescriptorSet_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_update) + +static bool js_cc_gfx_DescriptorSet_bindBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + uint32_t arg4 ; + cc::gfx::AccessFlags arg5 ; + + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindSampler__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + cc::gfx::AccessFlags arg5 ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindBufferJSB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + uint32_t arg4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->bindBufferJSB(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindBufferJSB) + +static bool js_cc_gfx_DescriptorSet_bindTextureJSB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + cc::gfx::AccessFlags arg5 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->bindTextureJSB(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindTextureJSB) + +static bool js_cc_gfx_DescriptorSet_bindSamplerJSB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + uint32_t arg4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->bindSamplerJSB(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindSamplerJSB) + +static bool js_cc_gfx_DescriptorSet_getBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Buffer *)((cc::gfx::DescriptorSet const *)arg1)->getBuffer(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_gfx_DescriptorSet_getTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Texture *)((cc::gfx::DescriptorSet const *)arg1)->getTexture(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_gfx_DescriptorSet_getSampler__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::Sampler *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Sampler *)((cc::gfx::DescriptorSet const *)arg1)->getSampler(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_gfx_DescriptorSet_bindBuffer__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_gfx_DescriptorSet_bindBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_gfx_DescriptorSet_bindBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_bindBuffer__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindBuffer) + +static bool js_cc_gfx_DescriptorSet_bindTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_gfx_DescriptorSet_bindTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_gfx_DescriptorSet_bindTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_bindTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindTexture) + +static bool js_cc_gfx_DescriptorSet_bindSampler__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_gfx_DescriptorSet_bindSampler__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_bindSampler__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindSampler) + +static bool js_cc_gfx_DescriptorSet_getBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Buffer *)((cc::gfx::DescriptorSet const *)arg1)->getBuffer(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_gfx_DescriptorSet_getBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_getBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DescriptorSet_getBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_getBuffer) + +static bool js_cc_gfx_DescriptorSet_getTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Texture *)((cc::gfx::DescriptorSet const *)arg1)->getTexture(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_gfx_DescriptorSet_getTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_getTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DescriptorSet_getTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_getTexture) + +static bool js_cc_gfx_DescriptorSet_getSampler__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Sampler *)((cc::gfx::DescriptorSet const *)arg1)->getSampler(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_gfx_DescriptorSet_getSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_getSampler__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DescriptorSet_getSampler__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_getSampler) + +static bool js_cc_gfx_DescriptorSet_layout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)cc_gfx_DescriptorSet_layout_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_gfx_DescriptorSet_layout_get) + +bool js_register_cc_gfx_DescriptorSet(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSet", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("layout", _SE(js_cc_gfx_DescriptorSet_layout_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_DescriptorSet_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_DescriptorSet_destroy)); + cls->defineFunction("update", _SE(js_cc_gfx_DescriptorSet_update)); + cls->defineFunction("bindBufferJSB", _SE(js_cc_gfx_DescriptorSet_bindBufferJSB)); + cls->defineFunction("bindTextureJSB", _SE(js_cc_gfx_DescriptorSet_bindTextureJSB)); + cls->defineFunction("bindSamplerJSB", _SE(js_cc_gfx_DescriptorSet_bindSamplerJSB)); + cls->defineFunction("bindBuffer", _SE(js_cc_gfx_DescriptorSet_bindBuffer)); + cls->defineFunction("bindTexture", _SE(js_cc_gfx_DescriptorSet_bindTexture)); + cls->defineFunction("bindSampler", _SE(js_cc_gfx_DescriptorSet_bindSampler)); + cls->defineFunction("getBuffer", _SE(js_cc_gfx_DescriptorSet_getBuffer)); + cls->defineFunction("getTexture", _SE(js_cc_gfx_DescriptorSet_getTexture)); + cls->defineFunction("getSampler", _SE(js_cc_gfx_DescriptorSet_getSampler)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSet)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSet_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSet_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetLayout_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayout) + +static bool js_delete_cc_gfx_DescriptorSetLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayout) + +static bool js_cc_gfx_DescriptorSetLayout_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + cc::gfx::DescriptorSetLayoutInfo *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::DescriptorSetLayoutInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSetLayout_initialize) + +static bool js_cc_gfx_DescriptorSetLayout_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSetLayout_destroy) + +static bool js_cc_gfx_DescriptorSetLayout_getDynamicBindings(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + ccstd::vector< uint32_t > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< uint32_t > *) &((cc::gfx::DescriptorSetLayout const *)arg1)->getDynamicBindings(); + + 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_gfx_DescriptorSetLayout_getDynamicBindings) + +static bool js_cc_gfx_DescriptorSetLayout_getDescriptorCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::DescriptorSetLayout const *)arg1)->getDescriptorCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSetLayout_getDescriptorCount) + +static bool js_cc_gfx_DescriptorSetLayout_bindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + cc::gfx::DescriptorSetLayoutBindingList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayoutBindingList *) &cc_gfx_DescriptorSetLayout_bindings_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_gfx_DescriptorSetLayout_bindings_get) + +bool js_register_cc_gfx_DescriptorSetLayout(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayout", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindings", _SE(js_cc_gfx_DescriptorSetLayout_bindings_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_DescriptorSetLayout_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_DescriptorSetLayout_destroy)); + cls->defineFunction("getDynamicBindings", _SE(js_cc_gfx_DescriptorSetLayout_getDynamicBindings)); + cls->defineFunction("getDescriptorCount", _SE(js_cc_gfx_DescriptorSetLayout_getDescriptorCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetLayout_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Framebuffer_class = nullptr; +se::Object* __jsb_cc_gfx_Framebuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Framebuffer) + +static bool js_delete_cc_gfx_Framebuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Framebuffer) + +static bool js_cc_gfx_Framebuffer_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = 0 ; + cc::gfx::FramebufferInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Framebuffer::computeHash((cc::gfx::FramebufferInfo const &)*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_FUNC(js_cc_gfx_Framebuffer_computeHash_static) + +static bool js_cc_gfx_Framebuffer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::FramebufferInfo *arg2 = 0 ; + cc::gfx::FramebufferInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::FramebufferInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Framebuffer_initialize) + +static bool js_cc_gfx_Framebuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Framebuffer_destroy) + +static bool js_cc_gfx_Framebuffer_getDepthStencilResolveTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Texture *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)((cc::gfx::Framebuffer const *)arg1)->getDepthStencilResolveTexture(); + + 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_gfx_Framebuffer_getDepthStencilResolveTexture) + +static bool js_cc_gfx_Framebuffer_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::RenderPass *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RenderPass *)cc_gfx_Framebuffer_renderPass_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_gfx_Framebuffer_renderPass_get) + +static bool js_cc_gfx_Framebuffer_colorTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::TextureList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureList *) &cc_gfx_Framebuffer_colorTextures_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_gfx_Framebuffer_colorTextures_get) + +static bool js_cc_gfx_Framebuffer_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_gfx_Framebuffer_depthStencilTexture_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_gfx_Framebuffer_depthStencilTexture_get) + +bool js_register_cc_gfx_Framebuffer(se::Object* obj) { + auto* cls = se::Class::create("Framebuffer", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderPass", _SE(js_cc_gfx_Framebuffer_renderPass_get), nullptr); + cls->defineProperty("colorTextures", _SE(js_cc_gfx_Framebuffer_colorTextures_get), nullptr); + cls->defineProperty("depthStencilTexture", _SE(js_cc_gfx_Framebuffer_depthStencilTexture_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Framebuffer_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Framebuffer_destroy)); + cls->defineFunction("getDepthStencilResolveTexture", _SE(js_cc_gfx_Framebuffer_getDepthStencilResolveTexture)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Framebuffer_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Framebuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Framebuffer_proto = cls->getProto(); + __jsb_cc_gfx_Framebuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_InputAssembler_class = nullptr; +se::Object* __jsb_cc_gfx_InputAssembler_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_InputAssembler) + +static bool js_delete_cc_gfx_InputAssembler(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_InputAssembler) + +static bool js_cc_gfx_InputAssembler_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::InputAssemblerInfo *arg2 = 0 ; + cc::gfx::InputAssemblerInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::InputAssemblerInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_InputAssembler_initialize) + +static bool js_cc_gfx_InputAssembler_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_InputAssembler_destroy) + +static bool js_cc_gfx_InputAssembler_vertexBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::BufferList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &cc_gfx_InputAssembler_vertexBuffers_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_gfx_InputAssembler_vertexBuffers_get) + +static bool js_cc_gfx_InputAssembler_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::AttributeList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::AttributeList *) &cc_gfx_InputAssembler_attributes_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_gfx_InputAssembler_attributes_get) + +static bool js_cc_gfx_InputAssembler_indexBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_gfx_InputAssembler_indexBuffer_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_gfx_InputAssembler_indexBuffer_get) + +static bool js_cc_gfx_InputAssembler_indirectBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_gfx_InputAssembler_indirectBuffer_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_gfx_InputAssembler_indirectBuffer_get) + +static bool js_cc_gfx_InputAssembler_attributesHash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_attributesHash_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_attributesHash_get) + +static bool js_cc_gfx_InputAssembler_drawInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::gfx::DrawInfo temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_gfx_InputAssembler_drawInfo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_drawInfo_set) + +static bool js_cc_gfx_InputAssembler_drawInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::DrawInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DrawInfo *) &cc_gfx_InputAssembler_drawInfo_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_gfx_InputAssembler_drawInfo_get) + +static bool js_cc_gfx_InputAssembler_vertexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_vertexCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_vertexCount_set) + +static bool js_cc_gfx_InputAssembler_vertexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_vertexCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_vertexCount_get) + +static bool js_cc_gfx_InputAssembler_firstVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_firstVertex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_firstVertex_set) + +static bool js_cc_gfx_InputAssembler_firstVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_firstVertex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_firstVertex_get) + +static bool js_cc_gfx_InputAssembler_indexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_indexCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_indexCount_set) + +static bool js_cc_gfx_InputAssembler_indexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_indexCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_indexCount_get) + +static bool js_cc_gfx_InputAssembler_firstIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_firstIndex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_firstIndex_set) + +static bool js_cc_gfx_InputAssembler_firstIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_firstIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_firstIndex_get) + +static bool js_cc_gfx_InputAssembler_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_vertexOffset_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_vertexOffset_set) + +static bool js_cc_gfx_InputAssembler_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_vertexOffset_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_vertexOffset_get) + +static bool js_cc_gfx_InputAssembler_instanceCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_instanceCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_instanceCount_set) + +static bool js_cc_gfx_InputAssembler_instanceCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_instanceCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_instanceCount_get) + +static bool js_cc_gfx_InputAssembler_firstInstance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_firstInstance_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_firstInstance_set) + +static bool js_cc_gfx_InputAssembler_firstInstance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_firstInstance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_firstInstance_get) + +bool js_register_cc_gfx_InputAssembler(se::Object* obj) { + auto* cls = se::Class::create("InputAssembler", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexBuffers", _SE(js_cc_gfx_InputAssembler_vertexBuffers_get), nullptr); + cls->defineProperty("attributes", _SE(js_cc_gfx_InputAssembler_attributes_get), nullptr); + cls->defineProperty("indexBuffer", _SE(js_cc_gfx_InputAssembler_indexBuffer_get), nullptr); + cls->defineProperty("indirectBuffer", _SE(js_cc_gfx_InputAssembler_indirectBuffer_get), nullptr); + cls->defineProperty("attributesHash", _SE(js_cc_gfx_InputAssembler_attributesHash_get), nullptr); + cls->defineProperty("drawInfo", _SE(js_cc_gfx_InputAssembler_drawInfo_get), _SE(js_cc_gfx_InputAssembler_drawInfo_set)); + cls->defineProperty("vertexCount", _SE(js_cc_gfx_InputAssembler_vertexCount_get), _SE(js_cc_gfx_InputAssembler_vertexCount_set)); + cls->defineProperty("firstVertex", _SE(js_cc_gfx_InputAssembler_firstVertex_get), _SE(js_cc_gfx_InputAssembler_firstVertex_set)); + cls->defineProperty("indexCount", _SE(js_cc_gfx_InputAssembler_indexCount_get), _SE(js_cc_gfx_InputAssembler_indexCount_set)); + cls->defineProperty("firstIndex", _SE(js_cc_gfx_InputAssembler_firstIndex_get), _SE(js_cc_gfx_InputAssembler_firstIndex_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_gfx_InputAssembler_vertexOffset_get), _SE(js_cc_gfx_InputAssembler_vertexOffset_set)); + cls->defineProperty("instanceCount", _SE(js_cc_gfx_InputAssembler_instanceCount_get), _SE(js_cc_gfx_InputAssembler_instanceCount_set)); + cls->defineProperty("firstInstance", _SE(js_cc_gfx_InputAssembler_firstInstance_get), _SE(js_cc_gfx_InputAssembler_firstInstance_set)); + + cls->defineFunction("initialize", _SE(js_cc_gfx_InputAssembler_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_InputAssembler_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_InputAssembler)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_InputAssembler_proto = cls->getProto(); + __jsb_cc_gfx_InputAssembler_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineLayout_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayout) + +static bool js_delete_cc_gfx_PipelineLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayout) + +static bool js_cc_gfx_PipelineLayout_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayout *arg1 = (cc::gfx::PipelineLayout *) NULL ; + cc::gfx::PipelineLayoutInfo *arg2 = 0 ; + cc::gfx::PipelineLayoutInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::PipelineLayoutInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineLayout_initialize) + +static bool js_cc_gfx_PipelineLayout_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayout *arg1 = (cc::gfx::PipelineLayout *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineLayout_destroy) + +static bool js_cc_gfx_PipelineLayout_getSetLayouts(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayout *arg1 = (cc::gfx::PipelineLayout *) NULL ; + cc::gfx::DescriptorSetLayoutList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayoutList *) &((cc::gfx::PipelineLayout const *)arg1)->getSetLayouts(); + + 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_gfx_PipelineLayout_getSetLayouts) + +bool js_register_cc_gfx_PipelineLayout(se::Object* obj) { + auto* cls = se::Class::create("PipelineLayout", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_gfx_PipelineLayout_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_PipelineLayout_destroy)); + cls->defineFunction("getSetLayouts", _SE(js_cc_gfx_PipelineLayout_getSetLayouts)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineLayout_proto = cls->getProto(); + __jsb_cc_gfx_PipelineLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineState_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineState) + +static bool js_delete_cc_gfx_PipelineState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineState) + +static bool js_cc_gfx_PipelineState_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PipelineStateInfo *arg2 = 0 ; + cc::gfx::PipelineStateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::PipelineStateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineState_initialize) + +static bool js_cc_gfx_PipelineState_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineState_destroy) + +static bool js_cc_gfx_PipelineState_getDynamicStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::DynamicStateFlags result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DynamicStateFlags)((cc::gfx::PipelineState const *)arg1)->getDynamicStates(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineState_getDynamicStates) + +static bool js_cc_gfx_PipelineState_getPipelineLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PipelineLayout *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PipelineLayout *)((cc::gfx::PipelineState const *)arg1)->getPipelineLayout(); + + 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_gfx_PipelineState_getPipelineLayout) + +static bool js_cc_gfx_PipelineState_shader_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)cc_gfx_PipelineState_shader_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_gfx_PipelineState_shader_get) + +static bool js_cc_gfx_PipelineState_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PrimitiveMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PrimitiveMode)cc_gfx_PipelineState_primitive_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_gfx_PipelineState_primitive_get) + +static bool js_cc_gfx_PipelineState_bindPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PipelineBindPoint result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PipelineBindPoint)cc_gfx_PipelineState_bindPoint_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_gfx_PipelineState_bindPoint_get) + +static bool js_cc_gfx_PipelineState_inputState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::InputState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputState *) &cc_gfx_PipelineState_inputState_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_gfx_PipelineState_inputState_get) + +static bool js_cc_gfx_PipelineState_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::RasterizerState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RasterizerState *) &cc_gfx_PipelineState_rasterizerState_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_gfx_PipelineState_rasterizerState_get) + +static bool js_cc_gfx_PipelineState_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::DepthStencilState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilState *) &cc_gfx_PipelineState_depthStencilState_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_gfx_PipelineState_depthStencilState_get) + +static bool js_cc_gfx_PipelineState_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::BlendState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BlendState *) &cc_gfx_PipelineState_blendState_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_gfx_PipelineState_blendState_get) + +static bool js_cc_gfx_PipelineState_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::RenderPass *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RenderPass *)cc_gfx_PipelineState_renderPass_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_gfx_PipelineState_renderPass_get) + +bool js_register_cc_gfx_PipelineState(se::Object* obj) { + auto* cls = se::Class::create("PipelineState", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("shader", _SE(js_cc_gfx_PipelineState_shader_get), nullptr); + cls->defineProperty("primitive", _SE(js_cc_gfx_PipelineState_primitive_get), nullptr); + cls->defineProperty("bindPoint", _SE(js_cc_gfx_PipelineState_bindPoint_get), nullptr); + cls->defineProperty("inputState", _SE(js_cc_gfx_PipelineState_inputState_get), nullptr); + cls->defineProperty("rasterizerState", _SE(js_cc_gfx_PipelineState_rasterizerState_get), nullptr); + cls->defineProperty("depthStencilState", _SE(js_cc_gfx_PipelineState_depthStencilState_get), nullptr); + cls->defineProperty("blendState", _SE(js_cc_gfx_PipelineState_blendState_get), nullptr); + cls->defineProperty("renderPass", _SE(js_cc_gfx_PipelineState_renderPass_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_PipelineState_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_PipelineState_destroy)); + cls->defineFunction("getDynamicStates", _SE(js_cc_gfx_PipelineState_getDynamicStates)); + cls->defineFunction("getPipelineLayout", _SE(js_cc_gfx_PipelineState_getPipelineLayout)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineState_proto = cls->getProto(); + __jsb_cc_gfx_PipelineState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_QueryPool_class = nullptr; +se::Object* __jsb_cc_gfx_QueryPool_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_QueryPool) + +static bool js_delete_cc_gfx_QueryPool(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_QueryPool) + +static bool js_cc_gfx_QueryPool_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + cc::gfx::QueryPoolInfo *arg2 = 0 ; + cc::gfx::QueryPoolInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::QueryPoolInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_initialize) + +static bool js_cc_gfx_QueryPool_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_destroy) + +static bool js_cc_gfx_QueryPool_hasResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->hasResult(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_hasResult) + +static bool js_cc_gfx_QueryPool_getResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg2 ; + uint64_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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getResult(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getResult) + +static bool js_cc_gfx_QueryPool_getType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + cc::gfx::QueryType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueryType)((cc::gfx::QueryPool const *)arg1)->getType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getType) + +static bool js_cc_gfx_QueryPool_getMaxQueryObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::QueryPool const *)arg1)->getMaxQueryObjects(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getMaxQueryObjects) + +static bool js_cc_gfx_QueryPool_getForceWait(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gfx::QueryPool const *)arg1)->getForceWait(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getForceWait) + +bool js_register_cc_gfx_QueryPool(se::Object* obj) { + auto* cls = se::Class::create("QueryPool", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_gfx_QueryPool_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_QueryPool_destroy)); + cls->defineFunction("hasResult", _SE(js_cc_gfx_QueryPool_hasResult)); + cls->defineFunction("getResult", _SE(js_cc_gfx_QueryPool_getResult)); + cls->defineFunction("getType", _SE(js_cc_gfx_QueryPool_getType)); + cls->defineFunction("getMaxQueryObjects", _SE(js_cc_gfx_QueryPool_getMaxQueryObjects)); + cls->defineFunction("getForceWait", _SE(js_cc_gfx_QueryPool_getForceWait)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_QueryPool)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_QueryPool_proto = cls->getProto(); + __jsb_cc_gfx_QueryPool_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Queue_class = nullptr; +se::Object* __jsb_cc_gfx_Queue_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Queue) + +static bool js_delete_cc_gfx_Queue(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Queue) + +static bool js_cc_gfx_Queue_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::QueueInfo *arg2 = 0 ; + cc::gfx::QueueInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::QueueInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Queue_initialize) + +static bool js_cc_gfx_Queue_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Queue_destroy) + +static bool js_cc_gfx_Queue_submit__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::CommandBuffer **arg2 = (cc::gfx::CommandBuffer **) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->submit((cc::gfx::CommandBuffer *const *)arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_Queue_submit__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::CommandBufferList *arg2 = 0 ; + cc::gfx::CommandBufferList temp2 ; + + arg1 = SE_THIS_OBJECT(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)->submit((cc::gfx::CommandBufferList const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Queue_submit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_Queue_submit__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Queue_submit__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Queue_submit) + +static bool js_cc_gfx_Queue_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::QueueType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueueType)cc_gfx_Queue_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Queue_type_get) + +bool js_register_cc_gfx_Queue(se::Object* obj) { + auto* cls = se::Class::create("Queue", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_Queue_type_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Queue_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Queue_destroy)); + cls->defineFunction("submit", _SE(js_cc_gfx_Queue_submit)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Queue)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Queue_proto = cls->getProto(); + __jsb_cc_gfx_Queue_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_RenderPass_class = nullptr; +se::Object* __jsb_cc_gfx_RenderPass_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_RenderPass) + +static bool js_delete_cc_gfx_RenderPass(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_RenderPass) + +static bool js_cc_gfx_RenderPass_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = 0 ; + cc::gfx::RenderPassInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::RenderPass::computeHash((cc::gfx::RenderPassInfo const &)*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_FUNC(js_cc_gfx_RenderPass_computeHash_static) + +static bool js_cc_gfx_RenderPass_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::RenderPassInfo *arg2 = 0 ; + cc::gfx::RenderPassInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::RenderPassInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_RenderPass_initialize) + +static bool js_cc_gfx_RenderPass_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_RenderPass_destroy) + +static bool js_cc_gfx_RenderPass_getColorAttachments(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::ColorAttachmentList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::ColorAttachmentList *) &((cc::gfx::RenderPass const *)arg1)->getColorAttachments(); + + 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_gfx_RenderPass_getColorAttachments) + +static bool js_cc_gfx_RenderPass_getDepthStencilAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::DepthStencilAttachment *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilAttachment *) &((cc::gfx::RenderPass const *)arg1)->getDepthStencilAttachment(); + + 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_gfx_RenderPass_getDepthStencilAttachment) + +static bool js_cc_gfx_RenderPass_getDepthStencilResolveAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::DepthStencilAttachment *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilAttachment *) &((cc::gfx::RenderPass const *)arg1)->getDepthStencilResolveAttachment(); + + 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_gfx_RenderPass_getDepthStencilResolveAttachment) + +static bool js_cc_gfx_RenderPass_getSubpasses(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::SubpassInfoList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SubpassInfoList *) &((cc::gfx::RenderPass const *)arg1)->getSubpasses(); + + 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_gfx_RenderPass_getSubpasses) + +static bool js_cc_gfx_RenderPass_getDependencies(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::SubpassDependencyList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SubpassDependencyList *) &((cc::gfx::RenderPass const *)arg1)->getDependencies(); + + 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_gfx_RenderPass_getDependencies) + +static bool js_cc_gfx_RenderPass_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_RenderPass_hash_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_gfx_RenderPass_hash_get) + +bool js_register_cc_gfx_RenderPass(se::Object* obj) { + auto* cls = se::Class::create("RenderPass", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hash", _SE(js_cc_gfx_RenderPass_hash_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_RenderPass_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_RenderPass_destroy)); + cls->defineFunction("getColorAttachments", _SE(js_cc_gfx_RenderPass_getColorAttachments)); + cls->defineFunction("getDepthStencilAttachment", _SE(js_cc_gfx_RenderPass_getDepthStencilAttachment)); + cls->defineFunction("getDepthStencilResolveAttachment", _SE(js_cc_gfx_RenderPass_getDepthStencilResolveAttachment)); + cls->defineFunction("getSubpasses", _SE(js_cc_gfx_RenderPass_getSubpasses)); + cls->defineFunction("getDependencies", _SE(js_cc_gfx_RenderPass_getDependencies)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_RenderPass_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_RenderPass)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_RenderPass_proto = cls->getProto(); + __jsb_cc_gfx_RenderPass_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Shader_class = nullptr; +se::Object* __jsb_cc_gfx_Shader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Shader) + +static bool js_delete_cc_gfx_Shader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Shader) + +static bool js_cc_gfx_Shader_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::ShaderInfo *arg2 = 0 ; + cc::gfx::ShaderInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::ShaderInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Shader_initialize) + +static bool js_cc_gfx_Shader_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Shader_destroy) + +static bool js_cc_gfx_Shader_getBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformStorageBufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformStorageBufferList *) &((cc::gfx::Shader const *)arg1)->getBuffers(); + + 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_gfx_Shader_getBuffers) + +static bool js_cc_gfx_Shader_getSamplerTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformSamplerTextureList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformSamplerTextureList *) &((cc::gfx::Shader const *)arg1)->getSamplerTextures(); + + 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_gfx_Shader_getSamplerTextures) + +static bool js_cc_gfx_Shader_getTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformTextureList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformTextureList *) &((cc::gfx::Shader const *)arg1)->getTextures(); + + 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_gfx_Shader_getTextures) + +static bool js_cc_gfx_Shader_getImages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformStorageImageList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformStorageImageList *) &((cc::gfx::Shader const *)arg1)->getImages(); + + 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_gfx_Shader_getImages) + +static bool js_cc_gfx_Shader_getSubpassInputs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformInputAttachmentList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformInputAttachmentList *) &((cc::gfx::Shader const *)arg1)->getSubpassInputs(); + + 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_gfx_Shader_getSubpassInputs) + +static bool js_cc_gfx_Shader_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Shader_name_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_gfx_Shader_name_get) + +static bool js_cc_gfx_Shader_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::ShaderStageList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::ShaderStageList *) &cc_gfx_Shader_stages_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_gfx_Shader_stages_get) + +static bool js_cc_gfx_Shader_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::AttributeList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::AttributeList *) &cc_gfx_Shader_attributes_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_gfx_Shader_attributes_get) + +static bool js_cc_gfx_Shader_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformBlockList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformBlockList *) &cc_gfx_Shader_blocks_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_gfx_Shader_blocks_get) + +static bool js_cc_gfx_Shader_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformSamplerList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformSamplerList *) &cc_gfx_Shader_samplers_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_gfx_Shader_samplers_get) + +bool js_register_cc_gfx_Shader(se::Object* obj) { + auto* cls = se::Class::create("Shader", obj, __jsb_cc_gfx_GFXObject_proto, 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_gfx_Shader_name_get), nullptr); + cls->defineProperty("stages", _SE(js_cc_gfx_Shader_stages_get), nullptr); + cls->defineProperty("attributes", _SE(js_cc_gfx_Shader_attributes_get), nullptr); + cls->defineProperty("blocks", _SE(js_cc_gfx_Shader_blocks_get), nullptr); + cls->defineProperty("samplers", _SE(js_cc_gfx_Shader_samplers_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Shader_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Shader_destroy)); + cls->defineFunction("getBuffers", _SE(js_cc_gfx_Shader_getBuffers)); + cls->defineFunction("getSamplerTextures", _SE(js_cc_gfx_Shader_getSamplerTextures)); + cls->defineFunction("getTextures", _SE(js_cc_gfx_Shader_getTextures)); + cls->defineFunction("getImages", _SE(js_cc_gfx_Shader_getImages)); + cls->defineFunction("getSubpassInputs", _SE(js_cc_gfx_Shader_getSubpassInputs)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Shader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Shader_proto = cls->getProto(); + __jsb_cc_gfx_Shader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Swapchain_class = nullptr; +se::Object* __jsb_cc_gfx_Swapchain_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Swapchain) + +static bool js_delete_cc_gfx_Swapchain(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Swapchain) + +static bool js_cc_gfx_Swapchain_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::SwapchainInfo *arg2 = 0 ; + cc::gfx::SwapchainInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::SwapchainInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_initialize) + +static bool js_cc_gfx_Swapchain_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_destroy) + +static bool js_cc_gfx_Swapchain_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::SurfaceTransform arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_resize) + +static bool js_cc_gfx_Swapchain_destroySurface(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroySurface(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_destroySurface) + +static bool js_cc_gfx_Swapchain_createSurface(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->createSurface(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_createSurface) + +static bool js_cc_gfx_Swapchain_getWindowId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::Swapchain const *)arg1)->getWindowId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_getWindowId) + +static bool js_cc_gfx_Swapchain_getWindowHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((cc::gfx::Swapchain const *)arg1)->getWindowHandle(); + + 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_gfx_Swapchain_getWindowHandle) + +static bool js_cc_gfx_Swapchain_getVSyncMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::VsyncMode result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::VsyncMode)((cc::gfx::Swapchain const *)arg1)->getVSyncMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_getVSyncMode) + +static bool js_cc_gfx_Swapchain_getGeneration(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::Swapchain const *)arg1)->getGeneration(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_getGeneration) + +static bool js_cc_gfx_Swapchain_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Swapchain_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Swapchain_width_get) + +static bool js_cc_gfx_Swapchain_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Swapchain_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Swapchain_height_get) + +static bool js_cc_gfx_Swapchain_surfaceTransform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::SurfaceTransform result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SurfaceTransform)cc_gfx_Swapchain_surfaceTransform_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_gfx_Swapchain_surfaceTransform_get) + +static bool js_cc_gfx_Swapchain_colorTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_gfx_Swapchain_colorTexture_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_gfx_Swapchain_colorTexture_get) + +static bool js_cc_gfx_Swapchain_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_gfx_Swapchain_depthStencilTexture_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_gfx_Swapchain_depthStencilTexture_get) + +bool js_register_cc_gfx_Swapchain(se::Object* obj) { + auto* cls = se::Class::create("Swapchain", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_gfx_Swapchain_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_gfx_Swapchain_height_get), nullptr); + cls->defineProperty("surfaceTransform", _SE(js_cc_gfx_Swapchain_surfaceTransform_get), nullptr); + cls->defineProperty("colorTexture", _SE(js_cc_gfx_Swapchain_colorTexture_get), nullptr); + cls->defineProperty("depthStencilTexture", _SE(js_cc_gfx_Swapchain_depthStencilTexture_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Swapchain_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Swapchain_destroy)); + cls->defineFunction("resize", _SE(js_cc_gfx_Swapchain_resize)); + cls->defineFunction("destroySurface", _SE(js_cc_gfx_Swapchain_destroySurface)); + cls->defineFunction("createSurface", _SE(js_cc_gfx_Swapchain_createSurface)); + cls->defineFunction("getWindowId", _SE(js_cc_gfx_Swapchain_getWindowId)); + cls->defineFunction("getWindowHandle", _SE(js_cc_gfx_Swapchain_getWindowHandle)); + cls->defineFunction("getVSyncMode", _SE(js_cc_gfx_Swapchain_getVSyncMode)); + cls->defineFunction("getGeneration", _SE(js_cc_gfx_Swapchain_getGeneration)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Swapchain)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Swapchain_proto = cls->getProto(); + __jsb_cc_gfx_Swapchain_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Texture_class = nullptr; +se::Object* __jsb_cc_gfx_Texture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Texture) + +static bool js_delete_cc_gfx_Texture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Texture) + +static bool js_cc_gfx_Texture_computeHash_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::TextureInfo *arg1 = 0 ; + cc::gfx::TextureInfo temp1 ; + ccstd::hash_t result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Texture::computeHash((cc::gfx::TextureInfo const &)*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; +} + +static bool js_cc_gfx_Texture_computeHash_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::TextureViewInfo *arg1 = 0 ; + cc::gfx::TextureViewInfo temp1 ; + ccstd::hash_t result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Texture::computeHash((cc::gfx::TextureViewInfo const &)*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; +} + +static bool js_cc_gfx_Texture_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_gfx_Texture_computeHash_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Texture_computeHash_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Texture_computeHash_static) + +static bool js_cc_gfx_Texture_initialize__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureInfo *arg2 = 0 ; + cc::gfx::TextureInfo temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::TextureInfo const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Texture_initialize__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureViewInfo *arg2 = 0 ; + cc::gfx::TextureViewInfo temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::TextureViewInfo const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Texture_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_gfx_Texture_initialize__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Texture_initialize__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Texture_initialize) + +static bool js_cc_gfx_Texture_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_resize) + +static bool js_cc_gfx_Texture_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_destroy) + +static bool js_cc_gfx_Texture_isTextureView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gfx::Texture const *)arg1)->isTextureView(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_isTextureView) + +static bool js_cc_gfx_Texture_getRaw(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)((cc::gfx::Texture const *)arg1)->getRaw(); + + 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_gfx_Texture_getRaw) + +static bool js_cc_gfx_Texture_getGLTextureHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::Texture const *)arg1)->getGLTextureHandle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_getGLTextureHandle) + +static bool js_cc_gfx_Texture_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureInfo *) &cc_gfx_Texture_info_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_gfx_Texture_info_get) + +static bool js_cc_gfx_Texture_viewInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureViewInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureViewInfo *) &cc_gfx_Texture_viewInfo_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_gfx_Texture_viewInfo_get) + +static bool js_cc_gfx_Texture_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Texture_width_get) + +static bool js_cc_gfx_Texture_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Texture_height_get) + +static bool js_cc_gfx_Texture_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::Format result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Format)cc_gfx_Texture_format_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_gfx_Texture_format_get) + +static bool js_cc_gfx_Texture_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Texture_size_get) + +static bool js_cc_gfx_Texture_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_hash_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_gfx_Texture_hash_get) + +bool js_register_cc_gfx_Texture(se::Object* obj) { + auto* cls = se::Class::create("Texture", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("info", _SE(js_cc_gfx_Texture_info_get), nullptr); + cls->defineProperty("viewInfo", _SE(js_cc_gfx_Texture_viewInfo_get), nullptr); + cls->defineProperty("width", _SE(js_cc_gfx_Texture_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_gfx_Texture_height_get), nullptr); + cls->defineProperty("format", _SE(js_cc_gfx_Texture_format_get), nullptr); + cls->defineProperty("size", _SE(js_cc_gfx_Texture_size_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_gfx_Texture_hash_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Texture_initialize)); + cls->defineFunction("resize", _SE(js_cc_gfx_Texture_resize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Texture_destroy)); + cls->defineFunction("isTextureView", _SE(js_cc_gfx_Texture_isTextureView)); + cls->defineFunction("getRaw", _SE(js_cc_gfx_Texture_getRaw)); + cls->defineFunction("getGLTextureHandle", _SE(js_cc_gfx_Texture_getGLTextureHandle)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Texture_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Texture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Texture_proto = cls->getProto(); + __jsb_cc_gfx_Texture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_GeneralBarrier_class = nullptr; +se::Object* __jsb_cc_gfx_GeneralBarrier_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrier) + +static bool js_new_cc_gfx_GeneralBarrier(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::GeneralBarrierInfo *arg1 = 0 ; + cc::gfx::GeneralBarrierInfo temp1 ; + cc::gfx::GeneralBarrier *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::GeneralBarrier *)new cc::gfx::GeneralBarrier((cc::gfx::GeneralBarrierInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_GeneralBarrier, __jsb_cc_gfx_GeneralBarrier_class, js_delete_cc_gfx_GeneralBarrier) + +static bool js_cc_gfx_GeneralBarrier_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = 0 ; + cc::gfx::GeneralBarrierInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::GeneralBarrier::computeHash((cc::gfx::GeneralBarrierInfo const &)*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_FUNC(js_cc_gfx_GeneralBarrier_computeHash_static) + +static bool js_cc_gfx_GeneralBarrier_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrier *arg1 = (cc::gfx::GeneralBarrier *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_GeneralBarrier_hash_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_gfx_GeneralBarrier_hash_get) + +static bool js_cc_gfx_GeneralBarrier_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrier *arg1 = (cc::gfx::GeneralBarrier *) NULL ; + cc::gfx::GeneralBarrierInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::GeneralBarrierInfo *) &cc_gfx_GeneralBarrier_info_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_gfx_GeneralBarrier_info_get) + +static bool js_delete_cc_gfx_GeneralBarrier(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrier) + +bool js_register_cc_gfx_GeneralBarrier(se::Object* obj) { + auto* cls = se::Class::create("GeneralBarrier", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_new_cc_gfx_GeneralBarrier)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hash", _SE(js_cc_gfx_GeneralBarrier_hash_get), nullptr); + cls->defineProperty("info", _SE(js_cc_gfx_GeneralBarrier_info_get), nullptr); + + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_GeneralBarrier_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_GeneralBarrier)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_GeneralBarrier_proto = cls->getProto(); + __jsb_cc_gfx_GeneralBarrier_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Sampler_class = nullptr; +se::Object* __jsb_cc_gfx_Sampler_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Sampler) + +static bool js_new_cc_gfx_Sampler(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::SamplerInfo *arg1 = 0 ; + cc::gfx::SamplerInfo temp1 ; + cc::gfx::Sampler *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::Sampler *)new cc::gfx::Sampler((cc::gfx::SamplerInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Sampler, __jsb_cc_gfx_Sampler_class, js_delete_cc_gfx_Sampler) + +static bool js_cc_gfx_Sampler_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = 0 ; + cc::gfx::SamplerInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Sampler::computeHash((cc::gfx::SamplerInfo const &)*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_FUNC(js_cc_gfx_Sampler_computeHash_static) + +static bool js_cc_gfx_Sampler_unpackFromHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::hash_t arg1 ; + cc::gfx::SamplerInfo result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::gfx::Sampler::unpackFromHash(SWIG_STD_MOVE(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_FUNC(js_cc_gfx_Sampler_unpackFromHash_static) + +static bool js_cc_gfx_Sampler_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Sampler *arg1 = (cc::gfx::Sampler *) NULL ; + cc::gfx::SamplerInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SamplerInfo *) &cc_gfx_Sampler_info_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_gfx_Sampler_info_get) + +static bool js_cc_gfx_Sampler_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Sampler *arg1 = (cc::gfx::Sampler *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Sampler_hash_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_gfx_Sampler_hash_get) + +static bool js_delete_cc_gfx_Sampler(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Sampler) + +bool js_register_cc_gfx_Sampler(se::Object* obj) { + auto* cls = se::Class::create("Sampler", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_new_cc_gfx_Sampler)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("info", _SE(js_cc_gfx_Sampler_info_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_gfx_Sampler_hash_get), nullptr); + + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Sampler_computeHash_static)); + cls->defineStaticFunction("unpackFromHash", _SE(js_cc_gfx_Sampler_unpackFromHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Sampler)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Sampler_proto = cls->getProto(); + __jsb_cc_gfx_Sampler_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureBarrier_class = nullptr; +se::Object* __jsb_cc_gfx_TextureBarrier_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrier) + +static bool js_new_cc_gfx_TextureBarrier(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::TextureBarrierInfo *arg1 = 0 ; + cc::gfx::TextureBarrierInfo temp1 ; + cc::gfx::TextureBarrier *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::TextureBarrier *)new cc::gfx::TextureBarrier((cc::gfx::TextureBarrierInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureBarrier, __jsb_cc_gfx_TextureBarrier_class, js_delete_cc_gfx_TextureBarrier) + +static bool js_cc_gfx_TextureBarrier_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = 0 ; + cc::gfx::TextureBarrierInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::TextureBarrier::computeHash((cc::gfx::TextureBarrierInfo const &)*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_FUNC(js_cc_gfx_TextureBarrier_computeHash_static) + +static bool js_cc_gfx_TextureBarrier_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrier *arg1 = (cc::gfx::TextureBarrier *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_TextureBarrier_hash_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_gfx_TextureBarrier_hash_get) + +static bool js_cc_gfx_TextureBarrier_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrier *arg1 = (cc::gfx::TextureBarrier *) NULL ; + cc::gfx::TextureBarrierInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureBarrierInfo *) &cc_gfx_TextureBarrier_info_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_gfx_TextureBarrier_info_get) + +static bool js_delete_cc_gfx_TextureBarrier(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrier) + +bool js_register_cc_gfx_TextureBarrier(se::Object* obj) { + auto* cls = se::Class::create("TextureBarrier", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_new_cc_gfx_TextureBarrier)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hash", _SE(js_cc_gfx_TextureBarrier_hash_get), nullptr); + cls->defineProperty("info", _SE(js_cc_gfx_TextureBarrier_info_get), nullptr); + + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_TextureBarrier_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureBarrier)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureBarrier_proto = cls->getProto(); + __jsb_cc_gfx_TextureBarrier_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferBarrier_class = nullptr; +se::Object* __jsb_cc_gfx_BufferBarrier_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrier) + +static bool js_cc_gfx_BufferBarrier_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = 0 ; + cc::gfx::BufferBarrierInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::BufferBarrier::computeHash((cc::gfx::BufferBarrierInfo const &)*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_FUNC(js_cc_gfx_BufferBarrier_computeHash_static) + +static bool js_cc_gfx_BufferBarrier_getInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrier *arg1 = (cc::gfx::BufferBarrier *) NULL ; + cc::gfx::BufferBarrierInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferBarrierInfo *) &((cc::gfx::BufferBarrier const *)arg1)->getInfo(); + + 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_gfx_BufferBarrier_getInfo) + +static bool js_cc_gfx_BufferBarrier_getHash(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrier *arg1 = (cc::gfx::BufferBarrier *) NULL ; + ccstd::hash_t *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(s); + if (nullptr == arg1) return true; + result = (ccstd::hash_t *) &((cc::gfx::BufferBarrier const *)arg1)->getHash(); + + 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_gfx_BufferBarrier_getHash) + +static bool js_delete_cc_gfx_BufferBarrier(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrier) + +bool js_register_cc_gfx_BufferBarrier(se::Object* obj) { + auto* cls = se::Class::create("BufferBarrier", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getInfo", _SE(js_cc_gfx_BufferBarrier_getInfo)); + cls->defineFunction("getHash", _SE(js_cc_gfx_BufferBarrier_getHash)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_BufferBarrier_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferBarrier)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferBarrier_proto = cls->getProto(); + __jsb_cc_gfx_BufferBarrier_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Device_class = nullptr; +se::Object* __jsb_cc_gfx_Device_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Device) + +static bool js_delete_cc_gfx_Device(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Device) + +static bool js_cc_gfx_Device_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DeviceInfo *arg2 = 0 ; + cc::gfx::DeviceInfo 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(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)(arg1)->initialize((cc::gfx::DeviceInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_initialize) + +static bool js_cc_gfx_Device_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_destroy) + +static bool js_cc_gfx_Device_acquire__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Swapchain **arg2 = (cc::gfx::Swapchain **) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->acquire((cc::gfx::Swapchain *const *)arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_Device_present(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->present(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_present) + +static bool js_cc_gfx_Device_flushCommands__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::CommandBuffer **arg2 = (cc::gfx::CommandBuffer **) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->flushCommands((cc::gfx::CommandBuffer *const *)arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_Device_createCommandBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::CommandBufferInfo *arg2 = 0 ; + cc::gfx::CommandBufferInfo temp2 ; + cc::gfx::CommandBuffer *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(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::gfx::CommandBuffer *)(arg1)->createCommandBuffer((cc::gfx::CommandBufferInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createCommandBuffer) + +static bool js_cc_gfx_Device_createQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueueInfo *arg2 = 0 ; + cc::gfx::QueueInfo temp2 ; + cc::gfx::Queue *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(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::gfx::Queue *)(arg1)->createQueue((cc::gfx::QueueInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createQueue) + +static bool js_cc_gfx_Device_createQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueryPoolInfo *arg2 = 0 ; + cc::gfx::QueryPoolInfo temp2 ; + cc::gfx::QueryPool *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(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::gfx::QueryPool *)(arg1)->createQueryPool((cc::gfx::QueryPoolInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createQueryPool) + +static bool js_cc_gfx_Device_createSwapchain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::SwapchainInfo *arg2 = 0 ; + cc::gfx::SwapchainInfo temp2 ; + cc::gfx::Swapchain *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(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::gfx::Swapchain *)(arg1)->createSwapchain((cc::gfx::SwapchainInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createSwapchain) + +static bool js_cc_gfx_Device_getSwapchains(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::vector< cc::gfx::Swapchain * > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gfx::Swapchain * > *) &((cc::gfx::Device const *)arg1)->getSwapchains(); + + 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_gfx_Device_getSwapchains) + +static bool js_cc_gfx_Device_createShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::ShaderInfo *arg2 = 0 ; + cc::gfx::ShaderInfo temp2 ; + cc::gfx::Shader *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(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::gfx::Shader *)(arg1)->createShader((cc::gfx::ShaderInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createShader) + +static bool js_cc_gfx_Device_createInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::InputAssemblerInfo *arg2 = 0 ; + cc::gfx::InputAssemblerInfo temp2 ; + cc::gfx::InputAssembler *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(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::gfx::InputAssembler *)(arg1)->createInputAssembler((cc::gfx::InputAssemblerInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createInputAssembler) + +static bool js_cc_gfx_Device_createRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::RenderPassInfo *arg2 = 0 ; + cc::gfx::RenderPassInfo temp2 ; + cc::gfx::RenderPass *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(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::gfx::RenderPass *)(arg1)->createRenderPass((cc::gfx::RenderPassInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createRenderPass) + +static bool js_cc_gfx_Device_createFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::FramebufferInfo *arg2 = 0 ; + cc::gfx::FramebufferInfo temp2 ; + cc::gfx::Framebuffer *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(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::gfx::Framebuffer *)(arg1)->createFramebuffer((cc::gfx::FramebufferInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createFramebuffer) + +static bool js_cc_gfx_Device_createDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DescriptorSetInfo *arg2 = 0 ; + cc::gfx::DescriptorSetInfo temp2 ; + cc::gfx::DescriptorSet *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(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::gfx::DescriptorSet *)(arg1)->createDescriptorSet((cc::gfx::DescriptorSetInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createDescriptorSet) + +static bool js_cc_gfx_Device_createDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DescriptorSetLayoutInfo *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutInfo temp2 ; + cc::gfx::DescriptorSetLayout *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(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::gfx::DescriptorSetLayout *)(arg1)->createDescriptorSetLayout((cc::gfx::DescriptorSetLayoutInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createDescriptorSetLayout) + +static bool js_cc_gfx_Device_createPipelineLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::PipelineLayoutInfo *arg2 = 0 ; + cc::gfx::PipelineLayoutInfo temp2 ; + cc::gfx::PipelineLayout *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(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::gfx::PipelineLayout *)(arg1)->createPipelineLayout((cc::gfx::PipelineLayoutInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createPipelineLayout) + +static bool js_cc_gfx_Device_createPipelineState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::PipelineStateInfo *arg2 = 0 ; + cc::gfx::PipelineStateInfo temp2 ; + cc::gfx::PipelineState *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(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::gfx::PipelineState *)(arg1)->createPipelineState((cc::gfx::PipelineStateInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createPipelineState) + +static bool js_cc_gfx_Device_getSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::SamplerInfo *arg2 = 0 ; + cc::gfx::SamplerInfo temp2 ; + cc::gfx::Sampler *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(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::gfx::Sampler *)(arg1)->getSampler((cc::gfx::SamplerInfo 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_gfx_Device_getSampler) + +static bool js_cc_gfx_Device_getGeneralBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::GeneralBarrierInfo *arg2 = 0 ; + cc::gfx::GeneralBarrierInfo temp2 ; + cc::gfx::GeneralBarrier *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(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::gfx::GeneralBarrier *)(arg1)->getGeneralBarrier((cc::gfx::GeneralBarrierInfo 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_gfx_Device_getGeneralBarrier) + +static bool js_cc_gfx_Device_getTextureBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::TextureBarrierInfo *arg2 = 0 ; + cc::gfx::TextureBarrierInfo temp2 ; + cc::gfx::TextureBarrier *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(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::gfx::TextureBarrier *)(arg1)->getTextureBarrier((cc::gfx::TextureBarrierInfo 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_gfx_Device_getTextureBarrier) + +static bool js_cc_gfx_Device_getBufferBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::BufferBarrierInfo *arg2 = 0 ; + cc::gfx::BufferBarrierInfo temp2 ; + cc::gfx::BufferBarrier *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(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::gfx::BufferBarrier *)(arg1)->getBufferBarrier((cc::gfx::BufferBarrierInfo 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_gfx_Device_getBufferBarrier) + +static bool js_cc_gfx_Device_getQueryPoolResults(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->getQueryPoolResults(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_getQueryPoolResults) + +static bool js_cc_gfx_Device_flushCommands__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::vector< cc::gfx::CommandBuffer * > *arg2 = 0 ; + ccstd::vector< cc::gfx::CommandBuffer * > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->flushCommands((ccstd::vector< cc::gfx::CommandBuffer * > const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Device_flushCommands(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_Device_flushCommands__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Device_flushCommands__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Device_flushCommands) + +static bool js_cc_gfx_Device_acquire__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::vector< cc::gfx::Swapchain * > *arg2 = 0 ; + ccstd::vector< cc::gfx::Swapchain * > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->acquire((ccstd::vector< cc::gfx::Swapchain * > const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Device_acquire(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_Device_acquire__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Device_acquire__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Device_acquire) + +static bool js_cc_gfx_Device_getQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueryPool *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueryPool *)((cc::gfx::Device const *)arg1)->getQueryPool(); + + 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_gfx_Device_getQueryPool) + +static bool js_cc_gfx_Device_hasFeature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Feature arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((cc::gfx::Device const *)arg1)->hasFeature(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_hasFeature) + +static bool js_cc_gfx_Device_getFormatFeatures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Format arg2 ; + cc::gfx::FormatFeature result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::FormatFeature)((cc::gfx::Device const *)arg1)->getFormatFeatures(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_getFormatFeatures) + +static bool js_cc_gfx_Device_bindingMappingInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::BindingMappingInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BindingMappingInfo *) &((cc::gfx::Device const *)arg1)->bindingMappingInfo(); + + 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_gfx_Device_bindingMappingInfo) + +static bool js_cc_gfx_Device_enableAutoBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableAutoBarrier(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_enableAutoBarrier) + +static bool js_cc_gfx_Device_getMaxSampleCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Format arg2 ; + cc::gfx::TextureUsage arg3 ; + cc::gfx::TextureFlags arg4 ; + cc::gfx::SampleCount result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::SampleCount)((cc::gfx::Device const *)arg1)->getMaxSampleCount(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_getMaxSampleCount) + +static bool js_cc_gfx_Device_gfxAPI_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::API result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::API)cc_gfx_Device_gfxAPI_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_gfx_Device_gfxAPI_get) + +static bool js_cc_gfx_Device_deviceName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Device_deviceName_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_gfx_Device_deviceName_get) + +static bool js_cc_gfx_Device_memoryStatus_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::MemoryStatus *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::MemoryStatus *) &cc_gfx_Device_memoryStatus_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_gfx_Device_memoryStatus_get) + +static bool js_cc_gfx_Device_queue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Queue *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Queue *)cc_gfx_Device_queue_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_gfx_Device_queue_get) + +static bool js_cc_gfx_Device_commandBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::CommandBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::CommandBuffer *)cc_gfx_Device_commandBuffer_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_gfx_Device_commandBuffer_get) + +static bool js_cc_gfx_Device_renderer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Device_renderer_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_gfx_Device_renderer_get) + +static bool js_cc_gfx_Device_vendor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Device_vendor_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_gfx_Device_vendor_get) + +static bool js_cc_gfx_Device_numDrawCalls_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Device_numDrawCalls_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Device_numDrawCalls_get) + +static bool js_cc_gfx_Device_numInstances_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Device_numInstances_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Device_numInstances_get) + +static bool js_cc_gfx_Device_numTris_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Device_numTris_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Device_numTris_get) + +static bool js_cc_gfx_Device_capabilities_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DeviceCaps *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DeviceCaps *) &cc_gfx_Device_capabilities_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_gfx_Device_capabilities_get) + +bool js_register_cc_gfx_Device(se::Object* obj) { + auto* cls = se::Class::create("Device", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("gfxAPI", _SE(js_cc_gfx_Device_gfxAPI_get), nullptr); + cls->defineProperty("deviceName", _SE(js_cc_gfx_Device_deviceName_get), nullptr); + cls->defineProperty("memoryStatus", _SE(js_cc_gfx_Device_memoryStatus_get), nullptr); + cls->defineProperty("queue", _SE(js_cc_gfx_Device_queue_get), nullptr); + cls->defineProperty("commandBuffer", _SE(js_cc_gfx_Device_commandBuffer_get), nullptr); + cls->defineProperty("renderer", _SE(js_cc_gfx_Device_renderer_get), nullptr); + cls->defineProperty("vendor", _SE(js_cc_gfx_Device_vendor_get), nullptr); + cls->defineProperty("numDrawCalls", _SE(js_cc_gfx_Device_numDrawCalls_get), nullptr); + cls->defineProperty("numInstances", _SE(js_cc_gfx_Device_numInstances_get), nullptr); + cls->defineProperty("numTris", _SE(js_cc_gfx_Device_numTris_get), nullptr); + cls->defineProperty("capabilities", _SE(js_cc_gfx_Device_capabilities_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Device_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Device_destroy)); + cls->defineFunction("present", _SE(js_cc_gfx_Device_present)); + cls->defineFunction("createCommandBuffer", _SE(js_cc_gfx_Device_createCommandBuffer)); + cls->defineFunction("createQueue", _SE(js_cc_gfx_Device_createQueue)); + cls->defineFunction("createQueryPool", _SE(js_cc_gfx_Device_createQueryPool)); + cls->defineFunction("createSwapchain", _SE(js_cc_gfx_Device_createSwapchain)); + cls->defineFunction("getSwapchains", _SE(js_cc_gfx_Device_getSwapchains)); + cls->defineFunction("createShader", _SE(js_cc_gfx_Device_createShader)); + cls->defineFunction("createInputAssembler", _SE(js_cc_gfx_Device_createInputAssembler)); + cls->defineFunction("createRenderPass", _SE(js_cc_gfx_Device_createRenderPass)); + cls->defineFunction("createFramebuffer", _SE(js_cc_gfx_Device_createFramebuffer)); + cls->defineFunction("createDescriptorSet", _SE(js_cc_gfx_Device_createDescriptorSet)); + cls->defineFunction("createDescriptorSetLayout", _SE(js_cc_gfx_Device_createDescriptorSetLayout)); + cls->defineFunction("createPipelineLayout", _SE(js_cc_gfx_Device_createPipelineLayout)); + cls->defineFunction("createPipelineState", _SE(js_cc_gfx_Device_createPipelineState)); + cls->defineFunction("getSampler", _SE(js_cc_gfx_Device_getSampler)); + cls->defineFunction("getGeneralBarrier", _SE(js_cc_gfx_Device_getGeneralBarrier)); + cls->defineFunction("getTextureBarrier", _SE(js_cc_gfx_Device_getTextureBarrier)); + cls->defineFunction("getBufferBarrier", _SE(js_cc_gfx_Device_getBufferBarrier)); + cls->defineFunction("getQueryPoolResults", _SE(js_cc_gfx_Device_getQueryPoolResults)); + cls->defineFunction("flushCommands", _SE(js_cc_gfx_Device_flushCommands)); + cls->defineFunction("acquire", _SE(js_cc_gfx_Device_acquire)); + cls->defineFunction("getQueryPool", _SE(js_cc_gfx_Device_getQueryPool)); + cls->defineFunction("hasFeature", _SE(js_cc_gfx_Device_hasFeature)); + cls->defineFunction("getFormatFeatures", _SE(js_cc_gfx_Device_getFormatFeatures)); + cls->defineFunction("bindingMappingInfo", _SE(js_cc_gfx_Device_bindingMappingInfo)); + cls->defineFunction("enableAutoBarrier", _SE(js_cc_gfx_Device_enableAutoBarrier)); + cls->defineFunction("getMaxSampleCount", _SE(js_cc_gfx_Device_getMaxSampleCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Device)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Device_proto = cls->getProto(); + __jsb_cc_gfx_Device_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceManager_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceManager) + +static bool js_cc_gfx_DeviceManager_create_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *result = 0 ; + + result = (cc::gfx::Device *)cc::gfx::DeviceManager::create(); + + 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_gfx_DeviceManager_create_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DeviceInfo *arg1 = 0 ; + cc::gfx::DeviceInfo temp1 ; + cc::gfx::Device *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::Device *)cc::gfx::DeviceManager::create((cc::gfx::DeviceInfo const &)*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; +} + +static bool js_cc_gfx_DeviceManager_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_gfx_DeviceManager_create_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DeviceManager_create_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DeviceManager_create_static) + +static bool js_new_cc_gfx_DeviceManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceManager *result; + result = (cc::gfx::DeviceManager *)new cc::gfx::DeviceManager(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceManager, __jsb_cc_gfx_DeviceManager_class, js_delete_cc_gfx_DeviceManager) + +static bool js_delete_cc_gfx_DeviceManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceManager) + +bool js_register_cc_gfx_DeviceManager(se::Object* obj) { + auto* cls = se::Class::create("DeviceManager", obj, nullptr, _SE(js_new_cc_gfx_DeviceManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("create", _SE(js_cc_gfx_DeviceManager_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceManager_proto = cls->getProto(); + __jsb_cc_gfx_DeviceManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_gfx(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("gfx", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("gfx", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_gfx_Size(ns); + js_register_cc_gfx_DeviceCaps(ns); + js_register_cc_gfx_DeviceOptions(ns); + js_register_cc_gfx_Offset(ns); + js_register_cc_gfx_Rect(ns); + js_register_cc_gfx_Extent(ns); + js_register_cc_gfx_TextureSubresLayers(ns); + js_register_cc_gfx_TextureSubresRange(ns); + js_register_cc_gfx_TextureCopy(ns); + js_register_cc_gfx_TextureBlit(ns); + js_register_cc_gfx_BufferTextureCopy(ns); + js_register_cc_gfx_Viewport(ns); + js_register_cc_gfx_Color(ns); + js_register_cc_gfx_MarkerInfo(ns); + js_register_cc_gfx_BindingMappingInfo(ns); + js_register_cc_gfx_SwapchainInfo(ns); + js_register_cc_gfx_DeviceInfo(ns); + js_register_cc_gfx_BufferInfo(ns); + js_register_cc_gfx_BufferViewInfo(ns); + js_register_cc_gfx_DrawInfo(ns); + js_register_cc_gfx_DispatchInfo(ns); + js_register_cc_gfx_IndirectBuffer(ns); + js_register_cc_gfx_TextureInfo(ns); + js_register_cc_gfx_TextureViewInfo(ns); + js_register_cc_gfx_SamplerInfo(ns); + js_register_cc_gfx_Uniform(ns); + js_register_cc_gfx_UniformBlock(ns); + js_register_cc_gfx_UniformSamplerTexture(ns); + js_register_cc_gfx_UniformSampler(ns); + js_register_cc_gfx_UniformTexture(ns); + js_register_cc_gfx_UniformStorageImage(ns); + js_register_cc_gfx_UniformStorageBuffer(ns); + js_register_cc_gfx_UniformInputAttachment(ns); + js_register_cc_gfx_ShaderStage(ns); + js_register_cc_gfx_Attribute(ns); + js_register_cc_gfx_ShaderInfo(ns); + js_register_cc_gfx_InputAssemblerInfo(ns); + js_register_cc_gfx_ColorAttachment(ns); + js_register_cc_gfx_DepthStencilAttachment(ns); + js_register_cc_gfx_SubpassInfo(ns); + js_register_cc_gfx_SubpassDependency(ns); + js_register_cc_gfx_RenderPassInfo(ns); + js_register_cc_gfx_ResourceRange(ns); + js_register_cc_gfx_GeneralBarrierInfo(ns); + js_register_cc_gfx_TextureBarrierInfo(ns); + js_register_cc_gfx_BufferBarrierInfo(ns); + js_register_cc_gfx_FramebufferInfo(ns); + js_register_cc_gfx_DescriptorSetLayoutBinding(ns); + js_register_cc_gfx_DescriptorSetLayoutInfo(ns); + js_register_cc_gfx_DescriptorSetInfo(ns); + js_register_cc_gfx_PipelineLayoutInfo(ns); + js_register_cc_gfx_InputState(ns); + js_register_cc_gfx_RasterizerState(ns); + js_register_cc_gfx_DepthStencilState(ns); + js_register_cc_gfx_BlendTarget(ns); + js_register_cc_gfx_BlendState(ns); + js_register_cc_gfx_PipelineStateInfo(ns); + js_register_cc_gfx_CommandBufferInfo(ns); + js_register_cc_gfx_QueueInfo(ns); + js_register_cc_gfx_QueryPoolInfo(ns); + js_register_cc_gfx_FormatInfo(ns); + js_register_cc_gfx_MemoryStatus(ns); + js_register_cc_gfx_DynamicStencilStates(ns); + js_register_cc_gfx_DynamicStates(ns); + js_register_cc_gfx_GFXObject(ns); + js_register_cc_gfx_Buffer(ns); + js_register_cc_gfx_CommandBuffer(ns); + js_register_cc_gfx_DescriptorSet(ns); + js_register_cc_gfx_DescriptorSetLayout(ns); + js_register_cc_gfx_Framebuffer(ns); + js_register_cc_gfx_InputAssembler(ns); + js_register_cc_gfx_PipelineLayout(ns); + js_register_cc_gfx_PipelineState(ns); + js_register_cc_gfx_QueryPool(ns); + js_register_cc_gfx_Queue(ns); + js_register_cc_gfx_RenderPass(ns); + js_register_cc_gfx_Shader(ns); + js_register_cc_gfx_Swapchain(ns); + js_register_cc_gfx_Texture(ns); + js_register_cc_gfx_GeneralBarrier(ns); + js_register_cc_gfx_Sampler(ns); + js_register_cc_gfx_TextureBarrier(ns); + js_register_cc_gfx_BufferBarrier(ns); + js_register_cc_gfx_Device(ns); + js_register_cc_gfx_DeviceManager(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_gfx_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_gfx_auto.h new file mode 100644 index 0000000000..5e44187b91 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_gfx_auto.h @@ -0,0 +1,725 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "renderer/GFXDeviceManager.h" + + + +bool register_all_gfx(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Size); +extern se::Object *__jsb_cc_gfx_Size_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Size_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Size * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceCaps); +extern se::Object *__jsb_cc_gfx_DeviceCaps_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceCaps_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceCaps * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceOptions); +extern se::Object *__jsb_cc_gfx_DeviceOptions_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Offset); +extern se::Object *__jsb_cc_gfx_Offset_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Offset_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Offset * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Rect); +extern se::Object *__jsb_cc_gfx_Rect_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Rect_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Rect * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Extent); +extern se::Object *__jsb_cc_gfx_Extent_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Extent_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Extent * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureSubresLayers); +extern se::Object *__jsb_cc_gfx_TextureSubresLayers_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureSubresLayers_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresLayers * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureSubresRange); +extern se::Object *__jsb_cc_gfx_TextureSubresRange_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureSubresRange_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresRange * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureCopy); +extern se::Object *__jsb_cc_gfx_TextureCopy_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureCopy_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureCopy * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureBlit); +extern se::Object *__jsb_cc_gfx_TextureBlit_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureBlit_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBlit * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferTextureCopy); +extern se::Object *__jsb_cc_gfx_BufferTextureCopy_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferTextureCopy_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferTextureCopy * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Viewport); +extern se::Object *__jsb_cc_gfx_Viewport_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Viewport_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Viewport * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Color); +extern se::Object *__jsb_cc_gfx_Color_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Color_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Color * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::MarkerInfo); +extern se::Object *__jsb_cc_gfx_MarkerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_MarkerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MarkerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BindingMappingInfo); +extern se::Object *__jsb_cc_gfx_BindingMappingInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BindingMappingInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BindingMappingInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SwapchainInfo); +extern se::Object *__jsb_cc_gfx_SwapchainInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SwapchainInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SwapchainInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceInfo); +extern se::Object *__jsb_cc_gfx_DeviceInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferInfo); +extern se::Object *__jsb_cc_gfx_BufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferViewInfo); +extern se::Object *__jsb_cc_gfx_BufferViewInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferViewInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferViewInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DrawInfo); +extern se::Object *__jsb_cc_gfx_DrawInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DrawInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DrawInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DispatchInfo); +extern se::Object *__jsb_cc_gfx_DispatchInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DispatchInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DispatchInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::IndirectBuffer); +extern se::Object *__jsb_cc_gfx_IndirectBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_IndirectBuffer_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::IndirectBuffer * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureInfo); +extern se::Object *__jsb_cc_gfx_TextureInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureViewInfo); +extern se::Object *__jsb_cc_gfx_TextureViewInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureViewInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureViewInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SamplerInfo); +extern se::Object *__jsb_cc_gfx_SamplerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SamplerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SamplerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Uniform); +extern se::Object *__jsb_cc_gfx_Uniform_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Uniform_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Uniform * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformBlock); +extern se::Object *__jsb_cc_gfx_UniformBlock_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformBlock_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformBlock * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformSamplerTexture); +extern se::Object *__jsb_cc_gfx_UniformSamplerTexture_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformSamplerTexture_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSamplerTexture * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformSampler); +extern se::Object *__jsb_cc_gfx_UniformSampler_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformSampler_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSampler * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformTexture); +extern se::Object *__jsb_cc_gfx_UniformTexture_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformTexture_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformTexture * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformStorageImage); +extern se::Object *__jsb_cc_gfx_UniformStorageImage_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformStorageImage_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageImage * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformStorageBuffer); +extern se::Object *__jsb_cc_gfx_UniformStorageBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformStorageBuffer_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageBuffer * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformInputAttachment); +extern se::Object *__jsb_cc_gfx_UniformInputAttachment_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformInputAttachment_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformInputAttachment * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ShaderStage); +extern se::Object *__jsb_cc_gfx_ShaderStage_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ShaderStage_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderStage * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Attribute); +extern se::Object *__jsb_cc_gfx_Attribute_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Attribute_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Attribute * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ShaderInfo); +extern se::Object *__jsb_cc_gfx_ShaderInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ShaderInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::InputAssemblerInfo); +extern se::Object *__jsb_cc_gfx_InputAssemblerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_InputAssemblerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputAssemblerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ColorAttachment); +extern se::Object *__jsb_cc_gfx_ColorAttachment_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ColorAttachment_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ColorAttachment * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DepthStencilAttachment); +extern se::Object *__jsb_cc_gfx_DepthStencilAttachment_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DepthStencilAttachment_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilAttachment * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SubpassInfo); +extern se::Object *__jsb_cc_gfx_SubpassInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SubpassInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SubpassDependency); +extern se::Object *__jsb_cc_gfx_SubpassDependency_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SubpassDependency_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassDependency * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::RenderPassInfo); +extern se::Object *__jsb_cc_gfx_RenderPassInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_RenderPassInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RenderPassInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ResourceRange); +extern se::Object *__jsb_cc_gfx_ResourceRange_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ResourceRange_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ResourceRange * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::GeneralBarrierInfo); +extern se::Object *__jsb_cc_gfx_GeneralBarrierInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_GeneralBarrierInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::GeneralBarrierInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureBarrierInfo); +extern se::Object *__jsb_cc_gfx_TextureBarrierInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureBarrierInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBarrierInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferBarrierInfo); +extern se::Object *__jsb_cc_gfx_BufferBarrierInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferBarrierInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferBarrierInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::FramebufferInfo); +extern se::Object *__jsb_cc_gfx_FramebufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_FramebufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FramebufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetLayoutBinding); +extern se::Object *__jsb_cc_gfx_DescriptorSetLayoutBinding_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetLayoutBinding_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutBinding * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetLayoutInfo); +extern se::Object *__jsb_cc_gfx_DescriptorSetLayoutInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetLayoutInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetInfo); +extern se::Object *__jsb_cc_gfx_DescriptorSetInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineLayoutInfo); +extern se::Object *__jsb_cc_gfx_PipelineLayoutInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineLayoutInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineLayoutInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::InputState); +extern se::Object *__jsb_cc_gfx_InputState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_InputState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::RasterizerState); +extern se::Object *__jsb_cc_gfx_RasterizerState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_RasterizerState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RasterizerState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DepthStencilState); +extern se::Object *__jsb_cc_gfx_DepthStencilState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DepthStencilState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BlendTarget); +extern se::Object *__jsb_cc_gfx_BlendTarget_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BlendTarget_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendTarget * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BlendState); +extern se::Object *__jsb_cc_gfx_BlendState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BlendState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineStateInfo); +extern se::Object *__jsb_cc_gfx_PipelineStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::CommandBufferInfo); +extern se::Object *__jsb_cc_gfx_CommandBufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_CommandBufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::CommandBufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::QueueInfo); +extern se::Object *__jsb_cc_gfx_QueueInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_QueueInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueueInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::QueryPoolInfo); +extern se::Object *__jsb_cc_gfx_QueryPoolInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_QueryPoolInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueryPoolInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::FormatInfo); +extern se::Object *__jsb_cc_gfx_FormatInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_FormatInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FormatInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::MemoryStatus); +extern se::Object *__jsb_cc_gfx_MemoryStatus_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_MemoryStatus_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MemoryStatus * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DynamicStencilStates); +extern se::Object *__jsb_cc_gfx_DynamicStencilStates_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DynamicStencilStates_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStencilStates * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DynamicStates); +extern se::Object *__jsb_cc_gfx_DynamicStates_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DynamicStates_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStates * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::GFXObject); +extern se::Object *__jsb_cc_gfx_GFXObject_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_GFXObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Buffer); +extern se::Object *__jsb_cc_gfx_Buffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Buffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::CommandBuffer); +extern se::Object *__jsb_cc_gfx_CommandBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_CommandBuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSet); +extern se::Object *__jsb_cc_gfx_DescriptorSet_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSet_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetLayout); +extern se::Object *__jsb_cc_gfx_DescriptorSetLayout_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetLayout_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Framebuffer); +extern se::Object *__jsb_cc_gfx_Framebuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Framebuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::InputAssembler); +extern se::Object *__jsb_cc_gfx_InputAssembler_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_InputAssembler_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineLayout); +extern se::Object *__jsb_cc_gfx_PipelineLayout_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineLayout_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineState); +extern se::Object *__jsb_cc_gfx_PipelineState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::QueryPool); +extern se::Object *__jsb_cc_gfx_QueryPool_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_QueryPool_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Queue); +extern se::Object *__jsb_cc_gfx_Queue_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Queue_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::RenderPass); +extern se::Object *__jsb_cc_gfx_RenderPass_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_RenderPass_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Shader); +extern se::Object *__jsb_cc_gfx_Shader_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Shader_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Swapchain); +extern se::Object *__jsb_cc_gfx_Swapchain_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Swapchain_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Texture); +extern se::Object *__jsb_cc_gfx_Texture_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Texture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::GeneralBarrier); +extern se::Object *__jsb_cc_gfx_GeneralBarrier_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_GeneralBarrier_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Sampler); +extern se::Object *__jsb_cc_gfx_Sampler_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Sampler_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureBarrier); +extern se::Object *__jsb_cc_gfx_TextureBarrier_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureBarrier_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferBarrier); +extern se::Object *__jsb_cc_gfx_BufferBarrier_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferBarrier_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Device); +extern se::Object *__jsb_cc_gfx_Device_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Device_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceManager); +extern se::Object *__jsb_cc_gfx_DeviceManager_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceManager_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_gi_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_gi_auto.cpp new file mode 100644 index 0000000000..316f13d740 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_gi_auto.cpp @@ -0,0 +1,3484 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_geometry_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gi_auto.h" + +using namespace cc; +using namespace cc::gi; + + +#define cc_gi_LightProbesData_probes_get(self_) self_->getProbes() +#define cc_gi_LightProbesData_probes_set(self_, val_) self_->setProbes(val_) + + +#define cc_gi_LightProbesData_tetrahedrons_get(self_) self_->getTetrahedrons() +#define cc_gi_LightProbesData_tetrahedrons_set(self_, val_) self_->setTetrahedrons(val_) + + +#define cc_gi_LightProbes_giScale_get(self_) self_->getGIScale() +#define cc_gi_LightProbes_giScale_set(self_, val_) self_->setGIScale(val_) + + +#define cc_gi_LightProbes_giSamples_get(self_) self_->getGISamples() +#define cc_gi_LightProbes_giSamples_set(self_, val_) self_->setGISamples(val_) + + +#define cc_gi_LightProbes_bounces_get(self_) self_->getBounces() +#define cc_gi_LightProbes_bounces_set(self_, val_) self_->setBounces(val_) + + +#define cc_gi_LightProbes_reduceRinging_get(self_) self_->getReduceRinging() +#define cc_gi_LightProbes_reduceRinging_set(self_, val_) self_->setReduceRinging(val_) + + +#define cc_gi_LightProbes_showProbe_get(self_) self_->isShowProbe() +#define cc_gi_LightProbes_showProbe_set(self_, val_) self_->setShowProbe(val_) + + +#define cc_gi_LightProbes_showWireframe_get(self_) self_->isShowWireframe() +#define cc_gi_LightProbes_showWireframe_set(self_, val_) self_->setShowWireframe(val_) + + +#define cc_gi_LightProbes_lightProbeSphereVolume_get(self_) self_->getLightProbeSphereVolume() +#define cc_gi_LightProbes_lightProbeSphereVolume_set(self_, val_) self_->setLightProbeSphereVolume(val_) + + +#define cc_gi_LightProbes_showConvex_get(self_) self_->isShowConvex() +#define cc_gi_LightProbes_showConvex_set(self_, val_) self_->setShowConvex(val_) + + +#define cc_gi_LightProbes_data_get(self_) self_->getData() +#define cc_gi_LightProbes_data_set(self_, val_) self_->setData(val_) + + +#define cc_gi_LightProbeInfo_giScale_get(self_) self_->getGIScale() +#define cc_gi_LightProbeInfo_giScale_set(self_, val_) self_->setGIScale(val_) + + +#define cc_gi_LightProbeInfo_giSamples_get(self_) self_->getGISamples() +#define cc_gi_LightProbeInfo_giSamples_set(self_, val_) self_->setGISamples(val_) + + +#define cc_gi_LightProbeInfo_bounces_get(self_) self_->getBounces() +#define cc_gi_LightProbeInfo_bounces_set(self_, val_) self_->setBounces(val_) + + +#define cc_gi_LightProbeInfo_lightProbeSphereVolume_get(self_) self_->getLightProbeSphereVolume() +#define cc_gi_LightProbeInfo_lightProbeSphereVolume_set(self_, val_) self_->setLightProbeSphereVolume(val_) + + +#define cc_gi_LightProbeInfo_reduceRinging_get(self_) self_->getReduceRinging() +#define cc_gi_LightProbeInfo_reduceRinging_set(self_, val_) self_->setReduceRinging(val_) + + +#define cc_gi_LightProbeInfo_showProbe_get(self_) self_->isShowProbe() +#define cc_gi_LightProbeInfo_showProbe_set(self_, val_) self_->setShowProbe(val_) + + +#define cc_gi_LightProbeInfo_showWireframe_get(self_) self_->isShowWireframe() +#define cc_gi_LightProbeInfo_showWireframe_set(self_, val_) self_->setShowWireframe(val_) + + +#define cc_gi_LightProbeInfo_showConvex_get(self_) self_->isShowConvex() +#define cc_gi_LightProbeInfo_showConvex_set(self_, val_) self_->setShowConvex(val_) + + +#define cc_gi_LightProbeInfo_data_get(self_) self_->getData() +#define cc_gi_LightProbeInfo_data_set(self_, val_) self_->setData(val_) + + + +se::Class* __jsb_cc_gi_Vertex_class = nullptr; +se::Object* __jsb_cc_gi_Vertex_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Vertex) + +static bool js_cc_gi_Vertex_coefficients_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->coefficients, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Vertex_coefficients_set) + +static bool js_cc_gi_Vertex_coefficients_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->coefficients, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->coefficients, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Vertex_coefficients_get) + +static bool js_cc_gi_Vertex_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Vertex_position_set) + +static bool js_cc_gi_Vertex_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Vertex_position_get) + +static bool js_cc_gi_Vertex_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Vertex_normal_set) + +static bool js_cc_gi_Vertex_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Vertex_normal_get) + +static bool js_new_cc_gi_Vertex__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Vertex *result; + result = (cc::gi::Vertex *)new cc::gi::Vertex(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Vertex__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + Vec3 *arg1 = 0 ; + Vec3 temp1 ; + cc::gi::Vertex *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gi::Vertex *)new cc::gi::Vertex((Vec3 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Vertex(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_gi_Vertex__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_gi_Vertex__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vertex"); + return false; +} +SE_BIND_CTOR(js_new_cc_gi_Vertex, __jsb_cc_gi_Vertex_class, js_delete_cc_gi_Vertex) + +static bool js_delete_cc_gi_Vertex(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Vertex) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Vertex * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("coefficients", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->coefficients), ctx); + } + + + json->getProperty("position", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->position), ctx); + } + + + json->getProperty("normal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normal), ctx); + } + + + return ok; +} + + +bool js_register_cc_gi_Vertex(se::Object* obj) { + auto* cls = se::Class::create("Vertex", obj, nullptr, _SE(js_new_cc_gi_Vertex)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("coefficients", _SE(js_cc_gi_Vertex_coefficients_get), _SE(js_cc_gi_Vertex_coefficients_set)); + cls->defineProperty("position", _SE(js_cc_gi_Vertex_position_get), _SE(js_cc_gi_Vertex_position_set)); + cls->defineProperty("normal", _SE(js_cc_gi_Vertex_normal_get), _SE(js_cc_gi_Vertex_normal_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Vertex)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_Vertex_proto = cls->getProto(); + __jsb_cc_gi_Vertex_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_CircumSphere_class = nullptr; +se::Object* __jsb_cc_gi_CircumSphere_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_CircumSphere) + +static bool js_cc_gi_CircumSphere_radiusSquared_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->radiusSquared, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_CircumSphere_radiusSquared_set) + +static bool js_cc_gi_CircumSphere_radiusSquared_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->radiusSquared, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_CircumSphere_radiusSquared_get) + +static bool js_cc_gi_CircumSphere_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_CircumSphere_center_set) + +static bool js_cc_gi_CircumSphere_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_CircumSphere_center_get) + +static bool js_new_cc_gi_CircumSphere(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::CircumSphere *result; + result = (cc::gi::CircumSphere *)new cc::gi::CircumSphere(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_CircumSphere, __jsb_cc_gi_CircumSphere_class, js_delete_cc_gi_CircumSphere) + +static bool js_cc_gi_CircumSphere_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + Vec3 *arg2 = 0 ; + Vec3 *arg3 = 0 ; + Vec3 *arg4 = 0 ; + Vec3 *arg5 = 0 ; + Vec3 temp2 ; + Vec3 temp3 ; + Vec3 temp4 ; + Vec3 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->init((Vec3 const &)*arg2,(Vec3 const &)*arg3,(Vec3 const &)*arg4,(Vec3 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_CircumSphere_init) + +static bool js_delete_cc_gi_CircumSphere(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_CircumSphere) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::CircumSphere * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("radiusSquared", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->radiusSquared), ctx); + } + + + json->getProperty("center", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->center), ctx); + } + + + return ok; +} + + +bool js_register_cc_gi_CircumSphere(se::Object* obj) { + auto* cls = se::Class::create("CircumSphere", obj, nullptr, _SE(js_new_cc_gi_CircumSphere)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("radiusSquared", _SE(js_cc_gi_CircumSphere_radiusSquared_get), _SE(js_cc_gi_CircumSphere_radiusSquared_set)); + cls->defineProperty("center", _SE(js_cc_gi_CircumSphere_center_get), _SE(js_cc_gi_CircumSphere_center_set)); + + cls->defineFunction("init", _SE(js_cc_gi_CircumSphere_init)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_CircumSphere)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_CircumSphere_proto = cls->getProto(); + __jsb_cc_gi_CircumSphere_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_Tetrahedron_class = nullptr; +se::Object* __jsb_cc_gi_Tetrahedron_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Tetrahedron) + +static bool js_cc_gi_Tetrahedron_invalid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->invalid); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_invalid_set) + +static bool js_cc_gi_Tetrahedron_invalid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->invalid, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_invalid_get) + +static bool js_cc_gi_Tetrahedron_vertex0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex0_set) + +static bool js_cc_gi_Tetrahedron_vertex0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex0, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex0_get) + +static bool js_cc_gi_Tetrahedron_vertex1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex1_set) + +static bool js_cc_gi_Tetrahedron_vertex1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex1, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex1_get) + +static bool js_cc_gi_Tetrahedron_vertex2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex2_set) + +static bool js_cc_gi_Tetrahedron_vertex2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex2, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex2_get) + +static bool js_cc_gi_Tetrahedron_vertex3_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex3_set) + +static bool js_cc_gi_Tetrahedron_vertex3_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex3, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex3_get) + +static bool js_cc_gi_Tetrahedron_neighbours_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->neighbours, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_neighbours_set) + +static bool js_cc_gi_Tetrahedron_neighbours_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->neighbours, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->neighbours, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_neighbours_get) + +static bool js_cc_gi_Tetrahedron_matrix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->matrix, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_matrix_set) + +static bool js_cc_gi_Tetrahedron_matrix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->matrix, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->matrix, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_matrix_get) + +static bool js_cc_gi_Tetrahedron_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_offset_set) + +static bool js_cc_gi_Tetrahedron_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->offset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_offset_get) + +static bool js_cc_gi_Tetrahedron_sphere_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sphere, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_sphere_set) + +static bool js_cc_gi_Tetrahedron_sphere_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sphere, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sphere, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_sphere_get) + +static bool js_new_cc_gi_Tetrahedron__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ; + int32_t arg2 ; + int32_t arg3 ; + int32_t arg4 ; + int32_t arg5 ; + cc::gi::Tetrahedron *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron((cc::gi::Delaunay const *)arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Tetrahedron__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ; + int32_t arg2 ; + int32_t arg3 ; + int32_t arg4 ; + cc::gi::Tetrahedron *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron((cc::gi::Delaunay const *)arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Tetrahedron__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *result; + result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Tetrahedron(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 5) { + ret = js_new_cc_gi_Tetrahedron__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_gi_Tetrahedron__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_gi_Tetrahedron__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Tetrahedron"); + return false; +} +SE_BIND_CTOR(js_new_cc_gi_Tetrahedron, __jsb_cc_gi_Tetrahedron_class, js_delete_cc_gi_Tetrahedron) + +static bool js_cc_gi_Tetrahedron_isInCircumSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + Vec3 *arg2 = 0 ; + Vec3 temp2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)((cc::gi::Tetrahedron const *)arg1)->isInCircumSphere((Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_isInCircumSphere) + +static bool js_cc_gi_Tetrahedron_contain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + int32_t arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((cc::gi::Tetrahedron const *)arg1)->contain(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_contain) + +static bool js_cc_gi_Tetrahedron_isInnerTetrahedron(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::Tetrahedron const *)arg1)->isInnerTetrahedron(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_isInnerTetrahedron) + +static bool js_cc_gi_Tetrahedron_isOuterCell(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::Tetrahedron const *)arg1)->isOuterCell(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_isOuterCell) + +static bool js_delete_cc_gi_Tetrahedron(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Tetrahedron) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Tetrahedron * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("invalid", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->invalid), ctx); + } + + + json->getProperty("vertex0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex0), ctx); + } + + + json->getProperty("vertex1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex1), ctx); + } + + + json->getProperty("vertex2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex2), ctx); + } + + + json->getProperty("vertex3", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex3), ctx); + } + + + json->getProperty("neighbours", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->neighbours), ctx); + } + + + json->getProperty("matrix", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->matrix), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("sphere", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sphere), ctx); + } + + + return ok; +} + + +bool js_register_cc_gi_Tetrahedron(se::Object* obj) { + auto* cls = se::Class::create("Tetrahedron", obj, nullptr, _SE(js_new_cc_gi_Tetrahedron)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("invalid", _SE(js_cc_gi_Tetrahedron_invalid_get), _SE(js_cc_gi_Tetrahedron_invalid_set)); + cls->defineProperty("vertex0", _SE(js_cc_gi_Tetrahedron_vertex0_get), _SE(js_cc_gi_Tetrahedron_vertex0_set)); + cls->defineProperty("vertex1", _SE(js_cc_gi_Tetrahedron_vertex1_get), _SE(js_cc_gi_Tetrahedron_vertex1_set)); + cls->defineProperty("vertex2", _SE(js_cc_gi_Tetrahedron_vertex2_get), _SE(js_cc_gi_Tetrahedron_vertex2_set)); + cls->defineProperty("vertex3", _SE(js_cc_gi_Tetrahedron_vertex3_get), _SE(js_cc_gi_Tetrahedron_vertex3_set)); + cls->defineProperty("neighbours", _SE(js_cc_gi_Tetrahedron_neighbours_get), _SE(js_cc_gi_Tetrahedron_neighbours_set)); + cls->defineProperty("matrix", _SE(js_cc_gi_Tetrahedron_matrix_get), _SE(js_cc_gi_Tetrahedron_matrix_set)); + cls->defineProperty("offset", _SE(js_cc_gi_Tetrahedron_offset_get), _SE(js_cc_gi_Tetrahedron_offset_set)); + cls->defineProperty("sphere", _SE(js_cc_gi_Tetrahedron_sphere_get), _SE(js_cc_gi_Tetrahedron_sphere_set)); + + cls->defineFunction("isInCircumSphere", _SE(js_cc_gi_Tetrahedron_isInCircumSphere)); + cls->defineFunction("contain", _SE(js_cc_gi_Tetrahedron_contain)); + cls->defineFunction("isInnerTetrahedron", _SE(js_cc_gi_Tetrahedron_isInnerTetrahedron)); + cls->defineFunction("isOuterCell", _SE(js_cc_gi_Tetrahedron_isOuterCell)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Tetrahedron)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_Tetrahedron_proto = cls->getProto(); + __jsb_cc_gi_Tetrahedron_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_Delaunay_class = nullptr; +se::Object* __jsb_cc_gi_Delaunay_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Delaunay) + +static bool js_new_cc_gi_Delaunay(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ccstd::vector< cc::gi::Vertex > *arg1 = 0 ; + ccstd::vector< cc::gi::Vertex > temp1 ; + cc::gi::Delaunay *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gi::Delaunay *)new cc::gi::Delaunay(*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_Delaunay, __jsb_cc_gi_Delaunay_class, js_delete_cc_gi_Delaunay) + +static bool js_delete_cc_gi_Delaunay(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Delaunay) + +static bool js_cc_gi_Delaunay_build(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ; + ccstd::vector< cc::gi::Tetrahedron > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->build(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Delaunay_build) + +bool js_register_cc_gi_Delaunay(se::Object* obj) { + auto* cls = se::Class::create("Delaunay", obj, nullptr, _SE(js_new_cc_gi_Delaunay)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("build", _SE(js_cc_gi_Delaunay_build)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Delaunay)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_Delaunay_proto = cls->getProto(); + __jsb_cc_gi_Delaunay_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_LightProbesData_class = nullptr; +se::Object* __jsb_cc_gi_LightProbesData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbesData) + +static bool js_new_cc_gi_LightProbesData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::LightProbesData *result; + result = (cc::gi::LightProbesData *)new cc::gi::LightProbesData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_LightProbesData, __jsb_cc_gi_LightProbesData_class, js_delete_cc_gi_LightProbesData) + +static bool js_cc_gi_LightProbesData_empty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbesData const *)arg1)->empty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_empty) + +static bool js_cc_gi_LightProbesData_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_reset) + +static bool js_cc_gi_LightProbesData_updateProbes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< Vec3 > *arg2 = 0 ; + ccstd::vector< Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->updateProbes(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_updateProbes) + +static bool js_cc_gi_LightProbesData_updateTetrahedrons(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateTetrahedrons(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_updateTetrahedrons) + +static bool js_cc_gi_LightProbesData_hasCoefficients(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbesData const *)arg1)->hasCoefficients(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_hasCoefficients) + +static bool js_cc_gi_LightProbesData_getInterpolationSHCoefficients(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + int32_t arg2 ; + Vec4 *arg3 = 0 ; + ccstd::vector< Vec3 > *arg4 = 0 ; + Vec4 temp3 ; + ccstd::vector< Vec3 > temp4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (bool)((cc::gi::LightProbesData const *)arg1)->getInterpolationSHCoefficients(arg2,(Vec4 const &)*arg3,*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_getInterpolationSHCoefficients) + +static bool js_cc_gi_LightProbesData_getInterpolationWeights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + Vec3 *arg2 = 0 ; + int32_t arg3 ; + Vec4 *arg4 = 0 ; + Vec3 temp2 ; + Vec4 temp4 ; + int32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = ((cc::gi::LightProbesData const *)arg1)->getInterpolationWeights((Vec3 const &)*arg2,arg3,*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_getInterpolationWeights) + +static bool js_cc_gi_LightProbesData__probes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_probes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData__probes_set) + +static bool js_cc_gi_LightProbesData__probes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_probes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_probes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData__probes_get) + +static bool js_cc_gi_LightProbesData__tetrahedrons_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_tetrahedrons, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData__tetrahedrons_set) + +static bool js_cc_gi_LightProbesData__tetrahedrons_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_tetrahedrons, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_tetrahedrons, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData__tetrahedrons_get) + +static bool js_cc_gi_LightProbesData_probes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Vertex > *arg2 = 0 ; + ccstd::vector< cc::gi::Vertex > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_gi_LightProbesData_probes_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData_probes_set) + +static bool js_cc_gi_LightProbesData_probes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Vertex > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gi::Vertex > *) &cc_gi_LightProbesData_probes_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData_probes_get) + +static bool js_cc_gi_LightProbesData_tetrahedrons_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Tetrahedron > *arg2 = 0 ; + ccstd::vector< cc::gi::Tetrahedron > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_gi_LightProbesData_tetrahedrons_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData_tetrahedrons_set) + +static bool js_cc_gi_LightProbesData_tetrahedrons_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Tetrahedron > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gi::Tetrahedron > *) &cc_gi_LightProbesData_tetrahedrons_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData_tetrahedrons_get) + +static bool js_delete_cc_gi_LightProbesData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbesData) + +bool js_register_cc_gi_LightProbesData(se::Object* obj) { + auto* cls = se::Class::create("LightProbesData", obj, nullptr, _SE(js_new_cc_gi_LightProbesData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_probes", _SE(js_cc_gi_LightProbesData__probes_get), _SE(js_cc_gi_LightProbesData__probes_set)); + cls->defineProperty("_tetrahedrons", _SE(js_cc_gi_LightProbesData__tetrahedrons_get), _SE(js_cc_gi_LightProbesData__tetrahedrons_set)); + cls->defineProperty("probes", _SE(js_cc_gi_LightProbesData_probes_get), _SE(js_cc_gi_LightProbesData_probes_set)); + cls->defineProperty("tetrahedrons", _SE(js_cc_gi_LightProbesData_tetrahedrons_get), _SE(js_cc_gi_LightProbesData_tetrahedrons_set)); + + cls->defineFunction("empty", _SE(js_cc_gi_LightProbesData_empty)); + cls->defineFunction("reset", _SE(js_cc_gi_LightProbesData_reset)); + cls->defineFunction("updateProbes", _SE(js_cc_gi_LightProbesData_updateProbes)); + cls->defineFunction("updateTetrahedrons", _SE(js_cc_gi_LightProbesData_updateTetrahedrons)); + cls->defineFunction("hasCoefficients", _SE(js_cc_gi_LightProbesData_hasCoefficients)); + cls->defineFunction("getInterpolationSHCoefficients", _SE(js_cc_gi_LightProbesData_getInterpolationSHCoefficients)); + cls->defineFunction("getInterpolationWeights", _SE(js_cc_gi_LightProbesData_getInterpolationWeights)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbesData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_LightProbesData_proto = cls->getProto(); + __jsb_cc_gi_LightProbesData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_LightProbes_class = nullptr; +se::Object* __jsb_cc_gi_LightProbes_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbes) + +static bool js_new_cc_gi_LightProbes(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::LightProbes *result; + result = (cc::gi::LightProbes *)new cc::gi::LightProbes(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_LightProbes, __jsb_cc_gi_LightProbes_class, js_delete_cc_gi_LightProbes) + +static bool js_delete_cc_gi_LightProbes(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbes) + +static bool js_cc_gi_LightProbes_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + cc::gi::LightProbeInfo *arg2 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbes_initialize) + +static bool js_cc_gi_LightProbes_empty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbes const *)arg1)->empty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbes_empty) + +static bool js_cc_gi_LightProbes__giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__giScale_set) + +static bool js_cc_gi_LightProbes__giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__giScale_get) + +static bool js_cc_gi_LightProbes__lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lightProbeSphereVolume, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbes__lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lightProbeSphereVolume, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbes__giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giSamples, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__giSamples_set) + +static bool js_cc_gi_LightProbes__giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giSamples, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__giSamples_get) + +static bool js_cc_gi_LightProbes__bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_bounces, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__bounces_set) + +static bool js_cc_gi_LightProbes__bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_bounces, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__bounces_get) + +static bool js_cc_gi_LightProbes__reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reduceRinging, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__reduceRinging_set) + +static bool js_cc_gi_LightProbes__reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reduceRinging, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__reduceRinging_get) + +static bool js_cc_gi_LightProbes__showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showProbe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__showProbe_set) + +static bool js_cc_gi_LightProbes__showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showProbe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__showProbe_get) + +static bool js_cc_gi_LightProbes__showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showWireframe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__showWireframe_set) + +static bool js_cc_gi_LightProbes__showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showWireframe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__showWireframe_get) + +static bool js_cc_gi_LightProbes__showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showConvex); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__showConvex_set) + +static bool js_cc_gi_LightProbes__showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showConvex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__showConvex_get) + +static bool js_cc_gi_LightProbes__data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__data_set) + +static bool js_cc_gi_LightProbes__data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_data, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_data, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__data_get) + +static bool js_cc_gi_LightProbes_giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_giScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_giScale_set) + +static bool js_cc_gi_LightProbes_giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbes_giScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_giScale_get) + +static bool js_cc_gi_LightProbes_giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbes_giSamples_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_giSamples_set) + +static bool js_cc_gi_LightProbes_giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbes_giSamples_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_giSamples_get) + +static bool js_cc_gi_LightProbes_bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbes_bounces_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_bounces_set) + +static bool js_cc_gi_LightProbes_bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbes_bounces_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_bounces_get) + +static bool js_cc_gi_LightProbes_reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_reduceRinging_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_reduceRinging_set) + +static bool js_cc_gi_LightProbes_reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbes_reduceRinging_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_reduceRinging_get) + +static bool js_cc_gi_LightProbes_showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_showProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_showProbe_set) + +static bool js_cc_gi_LightProbes_showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbes_showProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_showProbe_get) + +static bool js_cc_gi_LightProbes_showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_showWireframe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_showWireframe_set) + +static bool js_cc_gi_LightProbes_showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbes_showWireframe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_showWireframe_get) + +static bool js_cc_gi_LightProbes_lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_lightProbeSphereVolume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbes_lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbes_lightProbeSphereVolume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbes_showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_showConvex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_showConvex_set) + +static bool js_cc_gi_LightProbes_showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbes_showConvex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_showConvex_get) + +static bool js_cc_gi_LightProbes_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + cc::gi::LightProbesData *arg2 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_data_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_data_set) + +static bool js_cc_gi_LightProbes_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + cc::gi::LightProbesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbesData *)cc_gi_LightProbes_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_data_get) + +bool js_register_cc_gi_LightProbes(se::Object* obj) { + auto* cls = se::Class::create("LightProbes", obj, nullptr, _SE(js_new_cc_gi_LightProbes)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_giScale", _SE(js_cc_gi_LightProbes__giScale_get), _SE(js_cc_gi_LightProbes__giScale_set)); + cls->defineProperty("_lightProbeSphereVolume", _SE(js_cc_gi_LightProbes__lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbes__lightProbeSphereVolume_set)); + cls->defineProperty("_giSamples", _SE(js_cc_gi_LightProbes__giSamples_get), _SE(js_cc_gi_LightProbes__giSamples_set)); + cls->defineProperty("_bounces", _SE(js_cc_gi_LightProbes__bounces_get), _SE(js_cc_gi_LightProbes__bounces_set)); + cls->defineProperty("_reduceRinging", _SE(js_cc_gi_LightProbes__reduceRinging_get), _SE(js_cc_gi_LightProbes__reduceRinging_set)); + cls->defineProperty("_showProbe", _SE(js_cc_gi_LightProbes__showProbe_get), _SE(js_cc_gi_LightProbes__showProbe_set)); + cls->defineProperty("_showWireframe", _SE(js_cc_gi_LightProbes__showWireframe_get), _SE(js_cc_gi_LightProbes__showWireframe_set)); + cls->defineProperty("_showConvex", _SE(js_cc_gi_LightProbes__showConvex_get), _SE(js_cc_gi_LightProbes__showConvex_set)); + cls->defineProperty("_data", _SE(js_cc_gi_LightProbes__data_get), _SE(js_cc_gi_LightProbes__data_set)); + cls->defineProperty("giScale", _SE(js_cc_gi_LightProbes_giScale_get), _SE(js_cc_gi_LightProbes_giScale_set)); + cls->defineProperty("giSamples", _SE(js_cc_gi_LightProbes_giSamples_get), _SE(js_cc_gi_LightProbes_giSamples_set)); + cls->defineProperty("bounces", _SE(js_cc_gi_LightProbes_bounces_get), _SE(js_cc_gi_LightProbes_bounces_set)); + cls->defineProperty("reduceRinging", _SE(js_cc_gi_LightProbes_reduceRinging_get), _SE(js_cc_gi_LightProbes_reduceRinging_set)); + cls->defineProperty("showProbe", _SE(js_cc_gi_LightProbes_showProbe_get), _SE(js_cc_gi_LightProbes_showProbe_set)); + cls->defineProperty("showWireframe", _SE(js_cc_gi_LightProbes_showWireframe_get), _SE(js_cc_gi_LightProbes_showWireframe_set)); + cls->defineProperty("lightProbeSphereVolume", _SE(js_cc_gi_LightProbes_lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbes_lightProbeSphereVolume_set)); + cls->defineProperty("showConvex", _SE(js_cc_gi_LightProbes_showConvex_get), _SE(js_cc_gi_LightProbes_showConvex_set)); + cls->defineProperty("data", _SE(js_cc_gi_LightProbes_data_get), _SE(js_cc_gi_LightProbes_data_set)); + + cls->defineFunction("initialize", _SE(js_cc_gi_LightProbes_initialize)); + cls->defineFunction("empty", _SE(js_cc_gi_LightProbes_empty)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbes)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_LightProbes_proto = cls->getProto(); + __jsb_cc_gi_LightProbes_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_LightProbeInfo_class = nullptr; +se::Object* __jsb_cc_gi_LightProbeInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbeInfo) + +static bool js_new_cc_gi_LightProbeInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::LightProbeInfo *result; + result = (cc::gi::LightProbeInfo *)new cc::gi::LightProbeInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_LightProbeInfo, __jsb_cc_gi_LightProbeInfo_class, js_delete_cc_gi_LightProbeInfo) + +static bool js_delete_cc_gi_LightProbeInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbeInfo) + +static bool js_cc_gi_LightProbeInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Scene *arg2 = (cc::Scene *) NULL ; + cc::gi::LightProbes *arg3 = (cc::gi::LightProbes *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_activate) + +static bool js_cc_gi_LightProbeInfo_onProbeBakeFinished(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onProbeBakeFinished(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_onProbeBakeFinished) + +static bool js_cc_gi_LightProbeInfo_onProbeBakeCleared(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onProbeBakeCleared(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_onProbeBakeCleared) + +static bool js_cc_gi_LightProbeInfo_clearSHCoefficients(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearSHCoefficients(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_clearSHCoefficients) + +static bool js_cc_gi_LightProbeInfo_isUniqueNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbeInfo const *)arg1)->isUniqueNode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_isUniqueNode) + +static bool js_cc_gi_LightProbeInfo_addNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->addNode(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_addNode) + +static bool js_cc_gi_LightProbeInfo_removeNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->removeNode(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_removeNode) + +static bool js_cc_gi_LightProbeInfo_syncData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + ccstd::vector< Vec3 > *arg3 = 0 ; + ccstd::vector< Vec3 > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->syncData(arg2,(ccstd::vector< Vec3 > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_syncData) + +static bool js_cc_gi_LightProbeInfo_update__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} + +static bool js_cc_gi_LightProbeInfo_update__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} + +static bool js_cc_gi_LightProbeInfo_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_gi_LightProbeInfo_update__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_gi_LightProbeInfo_update__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_update) + +static bool js_cc_gi_LightProbeInfo__giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__giScale_set) + +static bool js_cc_gi_LightProbeInfo__giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__giScale_get) + +static bool js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lightProbeSphereVolume, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lightProbeSphereVolume, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbeInfo__giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giSamples, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__giSamples_set) + +static bool js_cc_gi_LightProbeInfo__giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giSamples, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__giSamples_get) + +static bool js_cc_gi_LightProbeInfo__bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_bounces, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__bounces_set) + +static bool js_cc_gi_LightProbeInfo__bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_bounces, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__bounces_get) + +static bool js_cc_gi_LightProbeInfo__reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reduceRinging, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__reduceRinging_set) + +static bool js_cc_gi_LightProbeInfo__reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reduceRinging, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__reduceRinging_get) + +static bool js_cc_gi_LightProbeInfo__showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showProbe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showProbe_set) + +static bool js_cc_gi_LightProbeInfo__showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showProbe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showProbe_get) + +static bool js_cc_gi_LightProbeInfo__showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showWireframe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showWireframe_set) + +static bool js_cc_gi_LightProbeInfo__showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showWireframe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showWireframe_get) + +static bool js_cc_gi_LightProbeInfo__showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showConvex); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showConvex_set) + +static bool js_cc_gi_LightProbeInfo__showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showConvex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showConvex_get) + +static bool js_cc_gi_LightProbeInfo__data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__data_set) + +static bool js_cc_gi_LightProbeInfo__data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_data, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_data, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__data_get) + +static bool js_cc_gi_LightProbeInfo_giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_giScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_giScale_set) + +static bool js_cc_gi_LightProbeInfo_giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbeInfo_giScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_giScale_get) + +static bool js_cc_gi_LightProbeInfo_giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbeInfo_giSamples_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_giSamples_set) + +static bool js_cc_gi_LightProbeInfo_giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbeInfo_giSamples_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_giSamples_get) + +static bool js_cc_gi_LightProbeInfo_bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbeInfo_bounces_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_bounces_set) + +static bool js_cc_gi_LightProbeInfo_bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbeInfo_bounces_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_bounces_get) + +static bool js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_lightProbeSphereVolume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbeInfo_lightProbeSphereVolume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbeInfo_reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_reduceRinging_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_reduceRinging_set) + +static bool js_cc_gi_LightProbeInfo_reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbeInfo_reduceRinging_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_reduceRinging_get) + +static bool js_cc_gi_LightProbeInfo_showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_showProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showProbe_set) + +static bool js_cc_gi_LightProbeInfo_showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbeInfo_showProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showProbe_get) + +static bool js_cc_gi_LightProbeInfo_showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_showWireframe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showWireframe_set) + +static bool js_cc_gi_LightProbeInfo_showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbeInfo_showWireframe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showWireframe_get) + +static bool js_cc_gi_LightProbeInfo_showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_showConvex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showConvex_set) + +static bool js_cc_gi_LightProbeInfo_showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbeInfo_showConvex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showConvex_get) + +static bool js_cc_gi_LightProbeInfo_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::gi::LightProbesData *arg2 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_data_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_data_set) + +static bool js_cc_gi_LightProbeInfo_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::gi::LightProbesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbesData *)cc_gi_LightProbeInfo_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_data_get) + +bool js_register_cc_gi_LightProbeInfo(se::Object* obj) { + auto* cls = se::Class::create("LightProbeInfo", obj, nullptr, _SE(js_new_cc_gi_LightProbeInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_giScale", _SE(js_cc_gi_LightProbeInfo__giScale_get), _SE(js_cc_gi_LightProbeInfo__giScale_set)); + cls->defineProperty("_lightProbeSphereVolume", _SE(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set)); + cls->defineProperty("_giSamples", _SE(js_cc_gi_LightProbeInfo__giSamples_get), _SE(js_cc_gi_LightProbeInfo__giSamples_set)); + cls->defineProperty("_bounces", _SE(js_cc_gi_LightProbeInfo__bounces_get), _SE(js_cc_gi_LightProbeInfo__bounces_set)); + cls->defineProperty("_reduceRinging", _SE(js_cc_gi_LightProbeInfo__reduceRinging_get), _SE(js_cc_gi_LightProbeInfo__reduceRinging_set)); + cls->defineProperty("_showProbe", _SE(js_cc_gi_LightProbeInfo__showProbe_get), _SE(js_cc_gi_LightProbeInfo__showProbe_set)); + cls->defineProperty("_showWireframe", _SE(js_cc_gi_LightProbeInfo__showWireframe_get), _SE(js_cc_gi_LightProbeInfo__showWireframe_set)); + cls->defineProperty("_showConvex", _SE(js_cc_gi_LightProbeInfo__showConvex_get), _SE(js_cc_gi_LightProbeInfo__showConvex_set)); + cls->defineProperty("_data", _SE(js_cc_gi_LightProbeInfo__data_get), _SE(js_cc_gi_LightProbeInfo__data_set)); + cls->defineProperty("giScale", _SE(js_cc_gi_LightProbeInfo_giScale_get), _SE(js_cc_gi_LightProbeInfo_giScale_set)); + cls->defineProperty("giSamples", _SE(js_cc_gi_LightProbeInfo_giSamples_get), _SE(js_cc_gi_LightProbeInfo_giSamples_set)); + cls->defineProperty("bounces", _SE(js_cc_gi_LightProbeInfo_bounces_get), _SE(js_cc_gi_LightProbeInfo_bounces_set)); + cls->defineProperty("lightProbeSphereVolume", _SE(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set)); + cls->defineProperty("reduceRinging", _SE(js_cc_gi_LightProbeInfo_reduceRinging_get), _SE(js_cc_gi_LightProbeInfo_reduceRinging_set)); + cls->defineProperty("showProbe", _SE(js_cc_gi_LightProbeInfo_showProbe_get), _SE(js_cc_gi_LightProbeInfo_showProbe_set)); + cls->defineProperty("showWireframe", _SE(js_cc_gi_LightProbeInfo_showWireframe_get), _SE(js_cc_gi_LightProbeInfo_showWireframe_set)); + cls->defineProperty("showConvex", _SE(js_cc_gi_LightProbeInfo_showConvex_get), _SE(js_cc_gi_LightProbeInfo_showConvex_set)); + cls->defineProperty("data", _SE(js_cc_gi_LightProbeInfo_data_get), _SE(js_cc_gi_LightProbeInfo_data_set)); + + cls->defineFunction("activate", _SE(js_cc_gi_LightProbeInfo_activate)); + cls->defineFunction("onProbeBakeFinished", _SE(js_cc_gi_LightProbeInfo_onProbeBakeFinished)); + cls->defineFunction("onProbeBakeCleared", _SE(js_cc_gi_LightProbeInfo_onProbeBakeCleared)); + cls->defineFunction("clearSHCoefficients", _SE(js_cc_gi_LightProbeInfo_clearSHCoefficients)); + cls->defineFunction("isUniqueNode", _SE(js_cc_gi_LightProbeInfo_isUniqueNode)); + cls->defineFunction("addNode", _SE(js_cc_gi_LightProbeInfo_addNode)); + cls->defineFunction("removeNode", _SE(js_cc_gi_LightProbeInfo_removeNode)); + cls->defineFunction("syncData", _SE(js_cc_gi_LightProbeInfo_syncData)); + cls->defineFunction("update", _SE(js_cc_gi_LightProbeInfo_update)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbeInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_LightProbeInfo_proto = cls->getProto(); + __jsb_cc_gi_LightProbeInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_gi(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_gi_Vertex(ns); + js_register_cc_gi_CircumSphere(ns); + js_register_cc_gi_Tetrahedron(ns); + js_register_cc_gi_Delaunay(ns); + js_register_cc_gi_LightProbesData(ns); + js_register_cc_gi_LightProbes(ns); + js_register_cc_gi_LightProbeInfo(ns); + + /* Register global variables & global functions */ + + + + return true; +} + + +#if defined(__clang__) +#pragma clang diagnostic pop +#elif defined(__GNUC__) || defined(__GNUG__) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_gi_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_gi_auto.h new file mode 100644 index 0000000000..79d476f6ab --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_gi_auto.h @@ -0,0 +1,92 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "gi/light-probe/Delaunay.h" +#include "gi/light-probe/LightProbe.h" + + + +bool register_all_gi(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::Vertex); +extern se::Object *__jsb_cc_gi_Vertex_proto; // NOLINT +extern se::Class * __jsb_cc_gi_Vertex_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Vertex * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::CircumSphere); +extern se::Object *__jsb_cc_gi_CircumSphere_proto; // NOLINT +extern se::Class * __jsb_cc_gi_CircumSphere_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::CircumSphere * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::Tetrahedron); +extern se::Object *__jsb_cc_gi_Tetrahedron_proto; // NOLINT +extern se::Class * __jsb_cc_gi_Tetrahedron_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Tetrahedron * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::Delaunay); +extern se::Object *__jsb_cc_gi_Delaunay_proto; // NOLINT +extern se::Class * __jsb_cc_gi_Delaunay_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::LightProbesData); +extern se::Object *__jsb_cc_gi_LightProbesData_proto; // NOLINT +extern se::Class * __jsb_cc_gi_LightProbesData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::LightProbes); +extern se::Object *__jsb_cc_gi_LightProbes_proto; // NOLINT +extern se::Class * __jsb_cc_gi_LightProbes_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::LightProbeInfo); +extern se::Object *__jsb_cc_gi_LightProbeInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gi_LightProbeInfo_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_network_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_network_auto.cpp new file mode 100644 index 0000000000..18259548b7 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_network_auto.cpp @@ -0,0 +1,811 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_network_auto.h" + + +#define cc_network_Downloader_onProgress_set(self_, val_) self_->setOnProgress(val_) + + + +se::Class* __jsb_cc_network_DownloadTask_class = nullptr; +se::Object* __jsb_cc_network_DownloadTask_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_network_DownloadTask) + +static bool js_cc_network_DownloadTask_identifier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->identifier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_identifier_set) + +static bool js_cc_network_DownloadTask_identifier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->identifier, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->identifier, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_identifier_get) + +static bool js_cc_network_DownloadTask_requestURL_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->requestURL, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_requestURL_set) + +static bool js_cc_network_DownloadTask_requestURL_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->requestURL, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->requestURL, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_requestURL_get) + +static bool js_cc_network_DownloadTask_storagePath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storagePath, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_storagePath_set) + +static bool js_cc_network_DownloadTask_storagePath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storagePath, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storagePath, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_storagePath_get) + +static bool js_cc_network_DownloadTask_header_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->header, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_header_set) + +static bool js_cc_network_DownloadTask_header_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->header, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->header, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_header_get) + +static bool js_new_cc_network_DownloadTask(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::network::DownloadTask *result; + result = (cc::network::DownloadTask *)new cc::network::DownloadTask(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_network_DownloadTask, __jsb_cc_network_DownloadTask_class, js_delete_cc_network_DownloadTask) + +static bool js_delete_cc_network_DownloadTask(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_network_DownloadTask) + +bool js_register_cc_network_DownloadTask(se::Object* obj) { + auto* cls = se::Class::create("DownloadTask", obj, nullptr, _SE(js_new_cc_network_DownloadTask)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("identifier", _SE(js_cc_network_DownloadTask_identifier_get), _SE(js_cc_network_DownloadTask_identifier_set)); + cls->defineProperty("requestURL", _SE(js_cc_network_DownloadTask_requestURL_get), _SE(js_cc_network_DownloadTask_requestURL_set)); + cls->defineProperty("storagePath", _SE(js_cc_network_DownloadTask_storagePath_get), _SE(js_cc_network_DownloadTask_storagePath_set)); + cls->defineProperty("header", _SE(js_cc_network_DownloadTask_header_get), _SE(js_cc_network_DownloadTask_header_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_network_DownloadTask)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_network_DownloadTask_proto = cls->getProto(); + __jsb_cc_network_DownloadTask_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_network_DownloaderHints_class = nullptr; +se::Object* __jsb_cc_network_DownloaderHints_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_network_DownloaderHints) + +static bool js_cc_network_DownloaderHints_countOfMaxProcessingTasks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->countOfMaxProcessingTasks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_set) + +static bool js_cc_network_DownloaderHints_countOfMaxProcessingTasks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->countOfMaxProcessingTasks, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_get) + +static bool js_cc_network_DownloaderHints_timeoutInSeconds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeoutInSeconds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloaderHints_timeoutInSeconds_set) + +static bool js_cc_network_DownloaderHints_timeoutInSeconds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeoutInSeconds, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloaderHints_timeoutInSeconds_get) + +static bool js_cc_network_DownloaderHints_tempFileNameSuffix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tempFileNameSuffix, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloaderHints_tempFileNameSuffix_set) + +static bool js_cc_network_DownloaderHints_tempFileNameSuffix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tempFileNameSuffix, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->tempFileNameSuffix, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloaderHints_tempFileNameSuffix_get) + +static bool js_new_cc_network_DownloaderHints(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::network::DownloaderHints *result; + result = (cc::network::DownloaderHints *)new cc::network::DownloaderHints(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_network_DownloaderHints, __jsb_cc_network_DownloaderHints_class, js_delete_cc_network_DownloaderHints) + +static bool js_delete_cc_network_DownloaderHints(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_network_DownloaderHints) + +template<> +bool sevalue_to_native(const se::Value &from, cc::network::DownloaderHints * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("countOfMaxProcessingTasks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->countOfMaxProcessingTasks), ctx); + } + + + json->getProperty("timeoutInSeconds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->timeoutInSeconds), ctx); + } + + + json->getProperty("tempFileNameSuffix", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tempFileNameSuffix), ctx); + } + + + return ok; +} + + +bool js_register_cc_network_DownloaderHints(se::Object* obj) { + auto* cls = se::Class::create("DownloaderHints", obj, nullptr, _SE(js_new_cc_network_DownloaderHints)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("countOfMaxProcessingTasks", _SE(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_get), _SE(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_set)); + cls->defineProperty("timeoutInSeconds", _SE(js_cc_network_DownloaderHints_timeoutInSeconds_get), _SE(js_cc_network_DownloaderHints_timeoutInSeconds_set)); + cls->defineProperty("tempFileNameSuffix", _SE(js_cc_network_DownloaderHints_tempFileNameSuffix_get), _SE(js_cc_network_DownloaderHints_tempFileNameSuffix_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_network_DownloaderHints)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_network_DownloaderHints_proto = cls->getProto(); + __jsb_cc_network_DownloaderHints_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_network_Downloader_class = nullptr; +se::Object* __jsb_cc_network_Downloader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_network_Downloader) + +static bool js_new_cc_network_Downloader__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::network::Downloader *result; + result = (cc::network::Downloader *)new cc::network::Downloader(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_network_Downloader__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = 0 ; + cc::network::DownloaderHints temp1 ; + cc::network::Downloader *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::network::Downloader *)new cc::network::Downloader((cc::network::DownloaderHints const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_network_Downloader(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_network_Downloader__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_network_Downloader__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Downloader"); + return false; +} +SE_BIND_CTOR(js_new_cc_network_Downloader, __jsb_cc_network_Downloader_class, js_delete_cc_network_Downloader) + +static bool js_delete_cc_network_Downloader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_network_Downloader) + +static bool js_cc_network_Downloader_onDataTaskSuccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onDataTaskSuccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onDataTaskSuccess_set) + +static bool js_cc_network_Downloader_onDataTaskSuccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onDataTaskSuccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onDataTaskSuccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onDataTaskSuccess_get) + +static bool js_cc_network_Downloader_onFileTaskSuccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onFileTaskSuccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onFileTaskSuccess_set) + +static bool js_cc_network_Downloader_onFileTaskSuccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onFileTaskSuccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onFileTaskSuccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onFileTaskSuccess_get) + +static bool js_cc_network_Downloader_onTaskProgress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onTaskProgress, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onTaskProgress_set) + +static bool js_cc_network_Downloader_onTaskProgress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onTaskProgress, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onTaskProgress, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onTaskProgress_get) + +static bool js_cc_network_Downloader_onTaskError_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onTaskError, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onTaskError_set) + +static bool js_cc_network_Downloader_onTaskError_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onTaskError, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onTaskError, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onTaskError_get) + +static bool js_cc_network_Downloader_setOnTaskProgress(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > *arg2 = 0 ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setOnTaskProgress((std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_network_Downloader_setOnTaskProgress) + +static bool js_cc_network_Downloader_abort(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + std::shared_ptr< cc::network::DownloadTask const > *arg2 = 0 ; + std::shared_ptr< cc::network::DownloadTask const > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->abort((std::shared_ptr< cc::network::DownloadTask const > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_network_Downloader_abort) + +static bool js_cc_network_Downloader_onProgress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > *arg2 = 0 ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_network_Downloader_onProgress_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onProgress_set) + +bool js_register_cc_network_Downloader(se::Object* obj) { + auto* cls = se::Class::create("Downloader", obj, nullptr, _SE(js_new_cc_network_Downloader)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("onDataTaskSuccess", _SE(js_cc_network_Downloader_onDataTaskSuccess_get), _SE(js_cc_network_Downloader_onDataTaskSuccess_set)); + cls->defineProperty("onFileTaskSuccess", _SE(js_cc_network_Downloader_onFileTaskSuccess_get), _SE(js_cc_network_Downloader_onFileTaskSuccess_set)); + cls->defineProperty("onTaskProgress", _SE(js_cc_network_Downloader_onTaskProgress_get), _SE(js_cc_network_Downloader_onTaskProgress_set)); + cls->defineProperty("onTaskError", _SE(js_cc_network_Downloader_onTaskError_get), _SE(js_cc_network_Downloader_onTaskError_set)); + cls->defineProperty("onProgress", nullptr, _SE(js_cc_network_Downloader_onProgress_set)); + + cls->defineFunction("setOnTaskProgress", _SE(js_cc_network_Downloader_setOnTaskProgress)); + cls->defineFunction("abort", _SE(js_cc_network_Downloader_abort)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_network_Downloader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_network_Downloader_proto = cls->getProto(); + __jsb_cc_network_Downloader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_network(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_network_DownloadTask(ns); + js_register_cc_network_DownloaderHints(ns); + js_register_cc_network_Downloader(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_network_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_network_auto.h new file mode 100644 index 0000000000..37cc477775 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_network_auto.h @@ -0,0 +1,63 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "network/Downloader.h" + + + +bool register_all_network(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::network::DownloadTask); +extern se::Object *__jsb_cc_network_DownloadTask_proto; // NOLINT +extern se::Class * __jsb_cc_network_DownloadTask_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::network::DownloaderHints); +extern se::Object *__jsb_cc_network_DownloaderHints_proto; // NOLINT +extern se::Class * __jsb_cc_network_DownloaderHints_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::network::DownloaderHints * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::network::Downloader); +extern se::Object *__jsb_cc_network_Downloader_proto; // NOLINT +extern se::Class * __jsb_cc_network_Downloader_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_physics_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_physics_auto.cpp new file mode 100644 index 0000000000..6f66fa96dc --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_physics_auto.cpp @@ -0,0 +1,9765 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_physics_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_geometry_auto.h" + + + +se::Class* __jsb_cc_physics_World_class = nullptr; +se::Object* __jsb_cc_physics_World_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_World) + +static bool js_new_cc_physics_World(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::World *result; + result = (cc::physics::World *)new cc::physics::World(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_World, __jsb_cc_physics_World_class, js_delete_cc_physics_World) + +static bool js_delete_cc_physics_World(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_World) + +static bool js_cc_physics_World_setGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setGravity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setGravity) + +static bool js_cc_physics_World_setAllowSleep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAllowSleep(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setAllowSleep) + +static bool js_cc_physics_World_step(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->step(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_step) + +static bool js_cc_physics_World_emitEvents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->emitEvents(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_emitEvents) + +static bool js_cc_physics_World_syncSceneToPhysics(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncSceneToPhysics(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_syncSceneToPhysics) + +static bool js_cc_physics_World_syncSceneWithCheck(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncSceneWithCheck(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_syncSceneWithCheck) + +static bool js_cc_physics_World_setDebugDrawFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::EPhysicsDrawFlags arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDebugDrawFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setDebugDrawFlags) + +static bool js_cc_physics_World_getDebugDrawFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::EPhysicsDrawFlags result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::physics::EPhysicsDrawFlags)(arg1)->getDebugDrawFlags(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_getDebugDrawFlags) + +static bool js_cc_physics_World_setDebugDrawConstraintSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugDrawConstraintSize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setDebugDrawConstraintSize) + +static bool js_cc_physics_World_getDebugDrawConstraintSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getDebugDrawConstraintSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_getDebugDrawConstraintSize) + +static bool js_cc_physics_World_setCollisionMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCollisionMatrix(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setCollisionMatrix) + +static bool js_cc_physics_World_getTriggerEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::TriggerEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::TriggerEventPair > > *) &(arg1)->getTriggerEventPairs(); + + 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_physics_World_getTriggerEventPairs) + +static bool js_cc_physics_World_getContactEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::ContactEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::ContactEventPair > > *) &(arg1)->getContactEventPairs(); + + 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_physics_World_getContactEventPairs) + +static bool js_cc_physics_World_getCCTShapeEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::CCTShapeEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::CCTShapeEventPair > > *) &(arg1)->getCCTShapeEventPairs(); + + 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_physics_World_getCCTShapeEventPairs) + +static bool js_cc_physics_World_getCCTTriggerEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::CCTTriggerEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::CCTTriggerEventPair > > *) &(arg1)->getCCTTriggerEventPairs(); + + 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_physics_World_getCCTTriggerEventPairs) + +static bool js_cc_physics_World_raycast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + cc::physics::RaycastOptions 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(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)(arg1)->raycast(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_raycast) + +static bool js_cc_physics_World_raycastClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + cc::physics::RaycastOptions 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(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)(arg1)->raycastClosest(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_raycastClosest) + +static bool js_cc_physics_World_raycastResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< cc::physics::RaycastResult > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::physics::RaycastResult > *) &(arg1)->raycastResult(); + + 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_physics_World_raycastResult) + +static bool js_cc_physics_World_raycastClosestResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastResult *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(s); + if (nullptr == arg1) return true; + result = (cc::physics::RaycastResult *) &(arg1)->raycastClosestResult(); + + 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_physics_World_raycastClosestResult) + +static bool js_cc_physics_World_sweepBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepBox(*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepBox) + +static bool js_cc_physics_World_sweepBoxClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepBoxClosest(*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepBoxClosest) + +static bool js_cc_physics_World_sweepSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->sweepSphere(*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepSphere) + +static bool js_cc_physics_World_sweepSphereClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->sweepSphereClosest(*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepSphereClosest) + +static bool js_cc_physics_World_sweepCapsule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepCapsule(*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepCapsule) + +static bool js_cc_physics_World_sweepCapsuleClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepCapsuleClosest(*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepCapsuleClosest) + +static bool js_cc_physics_World_sweepClosestResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastResult *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(s); + if (nullptr == arg1) return true; + result = (cc::physics::RaycastResult *) &(arg1)->sweepClosestResult(); + + 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_physics_World_sweepClosestResult) + +static bool js_cc_physics_World_sweepResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< cc::physics::RaycastResult > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::physics::RaycastResult > *) &(arg1)->sweepResult(); + + 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_physics_World_sweepResult) + +static bool js_cc_physics_World_createConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::ConvexDesc *arg2 = 0 ; + cc::physics::ConvexDesc 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(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 = (arg1)->createConvex(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createConvex) + +static bool js_cc_physics_World_createTrimesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::TrimeshDesc *arg2 = 0 ; + cc::physics::TrimeshDesc 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(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 = (arg1)->createTrimesh(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createTrimesh) + +static bool js_cc_physics_World_createHeightField(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::HeightFieldDesc *arg2 = 0 ; + cc::physics::HeightFieldDesc 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(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 = (arg1)->createHeightField(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createHeightField) + +static bool js_cc_physics_World_createMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + bool result; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->createMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createMaterial) + +static bool js_cc_physics_World_getFixedTimeStep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::physics::World const *)arg1)->getFixedTimeStep(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_getFixedTimeStep) + +static bool js_cc_physics_World_setFixedTimeStep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFixedTimeStep(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setFixedTimeStep) + +static bool js_cc_physics_World_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_destroy) + +bool js_register_cc_physics_World(se::Object* obj) { + auto* cls = se::Class::create("World", obj, nullptr, _SE(js_new_cc_physics_World)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setGravity", _SE(js_cc_physics_World_setGravity)); + cls->defineFunction("setAllowSleep", _SE(js_cc_physics_World_setAllowSleep)); + cls->defineFunction("step", _SE(js_cc_physics_World_step)); + cls->defineFunction("emitEvents", _SE(js_cc_physics_World_emitEvents)); + cls->defineFunction("syncSceneToPhysics", _SE(js_cc_physics_World_syncSceneToPhysics)); + cls->defineFunction("syncSceneWithCheck", _SE(js_cc_physics_World_syncSceneWithCheck)); + cls->defineFunction("setDebugDrawFlags", _SE(js_cc_physics_World_setDebugDrawFlags)); + cls->defineFunction("getDebugDrawFlags", _SE(js_cc_physics_World_getDebugDrawFlags)); + cls->defineFunction("setDebugDrawConstraintSize", _SE(js_cc_physics_World_setDebugDrawConstraintSize)); + cls->defineFunction("getDebugDrawConstraintSize", _SE(js_cc_physics_World_getDebugDrawConstraintSize)); + cls->defineFunction("setCollisionMatrix", _SE(js_cc_physics_World_setCollisionMatrix)); + cls->defineFunction("getTriggerEventPairs", _SE(js_cc_physics_World_getTriggerEventPairs)); + cls->defineFunction("getContactEventPairs", _SE(js_cc_physics_World_getContactEventPairs)); + cls->defineFunction("getCCTShapeEventPairs", _SE(js_cc_physics_World_getCCTShapeEventPairs)); + cls->defineFunction("getCCTTriggerEventPairs", _SE(js_cc_physics_World_getCCTTriggerEventPairs)); + cls->defineFunction("raycast", _SE(js_cc_physics_World_raycast)); + cls->defineFunction("raycastClosest", _SE(js_cc_physics_World_raycastClosest)); + cls->defineFunction("raycastResult", _SE(js_cc_physics_World_raycastResult)); + cls->defineFunction("raycastClosestResult", _SE(js_cc_physics_World_raycastClosestResult)); + cls->defineFunction("sweepBox", _SE(js_cc_physics_World_sweepBox)); + cls->defineFunction("sweepBoxClosest", _SE(js_cc_physics_World_sweepBoxClosest)); + cls->defineFunction("sweepSphere", _SE(js_cc_physics_World_sweepSphere)); + cls->defineFunction("sweepSphereClosest", _SE(js_cc_physics_World_sweepSphereClosest)); + cls->defineFunction("sweepCapsule", _SE(js_cc_physics_World_sweepCapsule)); + cls->defineFunction("sweepCapsuleClosest", _SE(js_cc_physics_World_sweepCapsuleClosest)); + cls->defineFunction("sweepClosestResult", _SE(js_cc_physics_World_sweepClosestResult)); + cls->defineFunction("sweepResult", _SE(js_cc_physics_World_sweepResult)); + cls->defineFunction("createConvex", _SE(js_cc_physics_World_createConvex)); + cls->defineFunction("createTrimesh", _SE(js_cc_physics_World_createTrimesh)); + cls->defineFunction("createHeightField", _SE(js_cc_physics_World_createHeightField)); + cls->defineFunction("createMaterial", _SE(js_cc_physics_World_createMaterial)); + cls->defineFunction("getFixedTimeStep", _SE(js_cc_physics_World_getFixedTimeStep)); + cls->defineFunction("setFixedTimeStep", _SE(js_cc_physics_World_setFixedTimeStep)); + cls->defineFunction("destroy", _SE(js_cc_physics_World_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_World)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_World_proto = cls->getProto(); + __jsb_cc_physics_World_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_RigidBody_class = nullptr; +se::Object* __jsb_cc_physics_RigidBody_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_RigidBody) + +static bool js_new_cc_physics_RigidBody(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::RigidBody *result; + result = (cc::physics::RigidBody *)new cc::physics::RigidBody(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_RigidBody, __jsb_cc_physics_RigidBody_class, js_delete_cc_physics_RigidBody) + +static bool js_delete_cc_physics_RigidBody(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_RigidBody) + +static bool js_cc_physics_RigidBody_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + cc::physics::ERigidBodyType arg3 ; + uint32_t arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_initialize) + +static bool js_cc_physics_RigidBody_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_onEnable) + +static bool js_cc_physics_RigidBody_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_onDisable) + +static bool js_cc_physics_RigidBody_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_onDestroy) + +static bool js_cc_physics_RigidBody_isAwake(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isAwake(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_isAwake) + +static bool js_cc_physics_RigidBody_isSleepy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isSleepy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_isSleepy) + +static bool js_cc_physics_RigidBody_isSleeping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isSleeping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_isSleeping) + +static bool js_cc_physics_RigidBody_setType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::physics::ERigidBodyType arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setType(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setType) + +static bool js_cc_physics_RigidBody_setMass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMass(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setMass) + +static bool js_cc_physics_RigidBody_setLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setLinearDamping) + +static bool js_cc_physics_RigidBody_setAngularDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAngularDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAngularDamping) + +static bool js_cc_physics_RigidBody_useGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useGravity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_useGravity) + +static bool js_cc_physics_RigidBody_useCCD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useCCD(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_useCCD) + +static bool js_cc_physics_RigidBody_setLinearFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearFactor(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setLinearFactor) + +static bool js_cc_physics_RigidBody_setAngularFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularFactor(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAngularFactor) + +static bool js_cc_physics_RigidBody_setAllowSleep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAllowSleep(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAllowSleep) + +static bool js_cc_physics_RigidBody_wakeUp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->wakeUp(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_wakeUp) + +static bool js_cc_physics_RigidBody_sleep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->sleep(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_sleep) + +static bool js_cc_physics_RigidBody_clearState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearState(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_clearState) + +static bool js_cc_physics_RigidBody_clearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearForces(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_clearForces) + +static bool js_cc_physics_RigidBody_clearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearVelocity(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_clearVelocity) + +static bool js_cc_physics_RigidBody_setSleepThreshold(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSleepThreshold(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setSleepThreshold) + +static bool js_cc_physics_RigidBody_getSleepThreshold(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getSleepThreshold(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getSleepThreshold) + +static bool js_cc_physics_RigidBody_getLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getLinearVelocity(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getLinearVelocity) + +static bool js_cc_physics_RigidBody_setLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setLinearVelocity) + +static bool js_cc_physics_RigidBody_getAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getAngularVelocity(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getAngularVelocity) + +static bool js_cc_physics_RigidBody_setAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAngularVelocity) + +static bool js_cc_physics_RigidBody_applyForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyForce(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyForce) + +static bool js_cc_physics_RigidBody_applyLocalForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyLocalForce(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyLocalForce) + +static bool js_cc_physics_RigidBody_applyImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyImpulse(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyImpulse) + +static bool js_cc_physics_RigidBody_applyLocalImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyLocalImpulse(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyLocalImpulse) + +static bool js_cc_physics_RigidBody_applyTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->applyTorque(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyTorque) + +static bool js_cc_physics_RigidBody_applyLocalTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->applyLocalTorque(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyLocalTorque) + +static bool js_cc_physics_RigidBody_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getGroup) + +static bool js_cc_physics_RigidBody_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setGroup) + +static bool js_cc_physics_RigidBody_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getMask) + +static bool js_cc_physics_RigidBody_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setMask) + +static bool js_cc_physics_RigidBody_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::RigidBody const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getObjectID) + +bool js_register_cc_physics_RigidBody(se::Object* obj) { + auto* cls = se::Class::create("RigidBody", obj, nullptr, _SE(js_new_cc_physics_RigidBody)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_RigidBody_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_RigidBody_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_RigidBody_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_RigidBody_onDestroy)); + cls->defineFunction("isAwake", _SE(js_cc_physics_RigidBody_isAwake)); + cls->defineFunction("isSleepy", _SE(js_cc_physics_RigidBody_isSleepy)); + cls->defineFunction("isSleeping", _SE(js_cc_physics_RigidBody_isSleeping)); + cls->defineFunction("setType", _SE(js_cc_physics_RigidBody_setType)); + cls->defineFunction("setMass", _SE(js_cc_physics_RigidBody_setMass)); + cls->defineFunction("setLinearDamping", _SE(js_cc_physics_RigidBody_setLinearDamping)); + cls->defineFunction("setAngularDamping", _SE(js_cc_physics_RigidBody_setAngularDamping)); + cls->defineFunction("useGravity", _SE(js_cc_physics_RigidBody_useGravity)); + cls->defineFunction("useCCD", _SE(js_cc_physics_RigidBody_useCCD)); + cls->defineFunction("setLinearFactor", _SE(js_cc_physics_RigidBody_setLinearFactor)); + cls->defineFunction("setAngularFactor", _SE(js_cc_physics_RigidBody_setAngularFactor)); + cls->defineFunction("setAllowSleep", _SE(js_cc_physics_RigidBody_setAllowSleep)); + cls->defineFunction("wakeUp", _SE(js_cc_physics_RigidBody_wakeUp)); + cls->defineFunction("sleep", _SE(js_cc_physics_RigidBody_sleep)); + cls->defineFunction("clearState", _SE(js_cc_physics_RigidBody_clearState)); + cls->defineFunction("clearForces", _SE(js_cc_physics_RigidBody_clearForces)); + cls->defineFunction("clearVelocity", _SE(js_cc_physics_RigidBody_clearVelocity)); + cls->defineFunction("setSleepThreshold", _SE(js_cc_physics_RigidBody_setSleepThreshold)); + cls->defineFunction("getSleepThreshold", _SE(js_cc_physics_RigidBody_getSleepThreshold)); + cls->defineFunction("getLinearVelocity", _SE(js_cc_physics_RigidBody_getLinearVelocity)); + cls->defineFunction("setLinearVelocity", _SE(js_cc_physics_RigidBody_setLinearVelocity)); + cls->defineFunction("getAngularVelocity", _SE(js_cc_physics_RigidBody_getAngularVelocity)); + cls->defineFunction("setAngularVelocity", _SE(js_cc_physics_RigidBody_setAngularVelocity)); + cls->defineFunction("applyForce", _SE(js_cc_physics_RigidBody_applyForce)); + cls->defineFunction("applyLocalForce", _SE(js_cc_physics_RigidBody_applyLocalForce)); + cls->defineFunction("applyImpulse", _SE(js_cc_physics_RigidBody_applyImpulse)); + cls->defineFunction("applyLocalImpulse", _SE(js_cc_physics_RigidBody_applyLocalImpulse)); + cls->defineFunction("applyTorque", _SE(js_cc_physics_RigidBody_applyTorque)); + cls->defineFunction("applyLocalTorque", _SE(js_cc_physics_RigidBody_applyLocalTorque)); + cls->defineFunction("getGroup", _SE(js_cc_physics_RigidBody_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_RigidBody_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_RigidBody_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_RigidBody_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_RigidBody_getObjectID)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_RigidBody)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_RigidBody_proto = cls->getProto(); + __jsb_cc_physics_RigidBody_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_SphereShape_class = nullptr; +se::Object* __jsb_cc_physics_SphereShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_SphereShape) + +static bool js_new_cc_physics_SphereShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::SphereShape *result; + result = (cc::physics::SphereShape *)new cc::physics::SphereShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_SphereShape, __jsb_cc_physics_SphereShape_class, js_delete_cc_physics_SphereShape) + +static bool js_delete_cc_physics_SphereShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_SphereShape) + +static bool js_cc_physics_SphereShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_initialize) + +static bool js_cc_physics_SphereShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_onEnable) + +static bool js_cc_physics_SphereShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_onDisable) + +static bool js_cc_physics_SphereShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_onDestroy) + +static bool js_cc_physics_SphereShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setMaterial) + +static bool js_cc_physics_SphereShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setAsTrigger) + +static bool js_cc_physics_SphereShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setCenter) + +static bool js_cc_physics_SphereShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_updateEventListener) + +static bool js_cc_physics_SphereShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_SphereShape_getAABB) + +static bool js_cc_physics_SphereShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_SphereShape_getBoundingSphere) + +static bool js_cc_physics_SphereShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_getGroup) + +static bool js_cc_physics_SphereShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setGroup) + +static bool js_cc_physics_SphereShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_getMask) + +static bool js_cc_physics_SphereShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setMask) + +static bool js_cc_physics_SphereShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::SphereShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_getObjectID) + +static bool js_cc_physics_SphereShape_setRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setRadius) + +bool js_register_cc_physics_SphereShape(se::Object* obj) { + auto* cls = se::Class::create("SphereShape", obj, nullptr, _SE(js_new_cc_physics_SphereShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_SphereShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_SphereShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_SphereShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_SphereShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_SphereShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_SphereShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_SphereShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_SphereShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_SphereShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_SphereShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_SphereShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_SphereShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_SphereShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_SphereShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_SphereShape_getObjectID)); + cls->defineFunction("setRadius", _SE(js_cc_physics_SphereShape_setRadius)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_SphereShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_SphereShape_proto = cls->getProto(); + __jsb_cc_physics_SphereShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_BoxShape_class = nullptr; +se::Object* __jsb_cc_physics_BoxShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_BoxShape) + +static bool js_new_cc_physics_BoxShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::BoxShape *result; + result = (cc::physics::BoxShape *)new cc::physics::BoxShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_BoxShape, __jsb_cc_physics_BoxShape_class, js_delete_cc_physics_BoxShape) + +static bool js_delete_cc_physics_BoxShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_BoxShape) + +static bool js_cc_physics_BoxShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_initialize) + +static bool js_cc_physics_BoxShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_onEnable) + +static bool js_cc_physics_BoxShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_onDisable) + +static bool js_cc_physics_BoxShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_onDestroy) + +static bool js_cc_physics_BoxShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setMaterial) + +static bool js_cc_physics_BoxShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setAsTrigger) + +static bool js_cc_physics_BoxShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setCenter) + +static bool js_cc_physics_BoxShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_updateEventListener) + +static bool js_cc_physics_BoxShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_BoxShape_getAABB) + +static bool js_cc_physics_BoxShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_BoxShape_getBoundingSphere) + +static bool js_cc_physics_BoxShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_getGroup) + +static bool js_cc_physics_BoxShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setGroup) + +static bool js_cc_physics_BoxShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_getMask) + +static bool js_cc_physics_BoxShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setMask) + +static bool js_cc_physics_BoxShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::BoxShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_getObjectID) + +static bool js_cc_physics_BoxShape_setSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setSize) + +bool js_register_cc_physics_BoxShape(se::Object* obj) { + auto* cls = se::Class::create("BoxShape", obj, nullptr, _SE(js_new_cc_physics_BoxShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_BoxShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_BoxShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_BoxShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_BoxShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_BoxShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_BoxShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_BoxShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_BoxShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_BoxShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_BoxShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_BoxShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_BoxShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_BoxShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_BoxShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_BoxShape_getObjectID)); + cls->defineFunction("setSize", _SE(js_cc_physics_BoxShape_setSize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_BoxShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_BoxShape_proto = cls->getProto(); + __jsb_cc_physics_BoxShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_CapsuleShape_class = nullptr; +se::Object* __jsb_cc_physics_CapsuleShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_CapsuleShape) + +static bool js_new_cc_physics_CapsuleShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::CapsuleShape *result; + result = (cc::physics::CapsuleShape *)new cc::physics::CapsuleShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_CapsuleShape, __jsb_cc_physics_CapsuleShape_class, js_delete_cc_physics_CapsuleShape) + +static bool js_delete_cc_physics_CapsuleShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_CapsuleShape) + +static bool js_cc_physics_CapsuleShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_initialize) + +static bool js_cc_physics_CapsuleShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_onEnable) + +static bool js_cc_physics_CapsuleShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_onDisable) + +static bool js_cc_physics_CapsuleShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_onDestroy) + +static bool js_cc_physics_CapsuleShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setMaterial) + +static bool js_cc_physics_CapsuleShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setAsTrigger) + +static bool js_cc_physics_CapsuleShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setCenter) + +static bool js_cc_physics_CapsuleShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_updateEventListener) + +static bool js_cc_physics_CapsuleShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_CapsuleShape_getAABB) + +static bool js_cc_physics_CapsuleShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_CapsuleShape_getBoundingSphere) + +static bool js_cc_physics_CapsuleShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_getGroup) + +static bool js_cc_physics_CapsuleShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setGroup) + +static bool js_cc_physics_CapsuleShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_getMask) + +static bool js_cc_physics_CapsuleShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setMask) + +static bool js_cc_physics_CapsuleShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::CapsuleShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_getObjectID) + +static bool js_cc_physics_CapsuleShape_setRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setRadius) + +static bool js_cc_physics_CapsuleShape_setCylinderHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCylinderHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setCylinderHeight) + +static bool js_cc_physics_CapsuleShape_setDirection(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::physics::EAxisDirection arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDirection(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setDirection) + +bool js_register_cc_physics_CapsuleShape(se::Object* obj) { + auto* cls = se::Class::create("CapsuleShape", obj, nullptr, _SE(js_new_cc_physics_CapsuleShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_CapsuleShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_CapsuleShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_CapsuleShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_CapsuleShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_CapsuleShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_CapsuleShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_CapsuleShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_CapsuleShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_CapsuleShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_CapsuleShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_CapsuleShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_CapsuleShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_CapsuleShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_CapsuleShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_CapsuleShape_getObjectID)); + cls->defineFunction("setRadius", _SE(js_cc_physics_CapsuleShape_setRadius)); + cls->defineFunction("setCylinderHeight", _SE(js_cc_physics_CapsuleShape_setCylinderHeight)); + cls->defineFunction("setDirection", _SE(js_cc_physics_CapsuleShape_setDirection)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_CapsuleShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_CapsuleShape_proto = cls->getProto(); + __jsb_cc_physics_CapsuleShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_PlaneShape_class = nullptr; +se::Object* __jsb_cc_physics_PlaneShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_PlaneShape) + +static bool js_new_cc_physics_PlaneShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::PlaneShape *result; + result = (cc::physics::PlaneShape *)new cc::physics::PlaneShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_PlaneShape, __jsb_cc_physics_PlaneShape_class, js_delete_cc_physics_PlaneShape) + +static bool js_delete_cc_physics_PlaneShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_PlaneShape) + +static bool js_cc_physics_PlaneShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_initialize) + +static bool js_cc_physics_PlaneShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_onEnable) + +static bool js_cc_physics_PlaneShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_onDisable) + +static bool js_cc_physics_PlaneShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_onDestroy) + +static bool js_cc_physics_PlaneShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setMaterial) + +static bool js_cc_physics_PlaneShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setAsTrigger) + +static bool js_cc_physics_PlaneShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setCenter) + +static bool js_cc_physics_PlaneShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_updateEventListener) + +static bool js_cc_physics_PlaneShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_PlaneShape_getAABB) + +static bool js_cc_physics_PlaneShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_PlaneShape_getBoundingSphere) + +static bool js_cc_physics_PlaneShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_getGroup) + +static bool js_cc_physics_PlaneShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setGroup) + +static bool js_cc_physics_PlaneShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_getMask) + +static bool js_cc_physics_PlaneShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setMask) + +static bool js_cc_physics_PlaneShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::PlaneShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_getObjectID) + +static bool js_cc_physics_PlaneShape_setConstant(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setConstant(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setConstant) + +static bool js_cc_physics_PlaneShape_setNormal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setNormal(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setNormal) + +bool js_register_cc_physics_PlaneShape(se::Object* obj) { + auto* cls = se::Class::create("PlaneShape", obj, nullptr, _SE(js_new_cc_physics_PlaneShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_PlaneShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_PlaneShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_PlaneShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_PlaneShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_PlaneShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_PlaneShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_PlaneShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_PlaneShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_PlaneShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_PlaneShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_PlaneShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_PlaneShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_PlaneShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_PlaneShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_PlaneShape_getObjectID)); + cls->defineFunction("setConstant", _SE(js_cc_physics_PlaneShape_setConstant)); + cls->defineFunction("setNormal", _SE(js_cc_physics_PlaneShape_setNormal)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_PlaneShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_PlaneShape_proto = cls->getProto(); + __jsb_cc_physics_PlaneShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_TrimeshShape_class = nullptr; +se::Object* __jsb_cc_physics_TrimeshShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_TrimeshShape) + +static bool js_new_cc_physics_TrimeshShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::TrimeshShape *result; + result = (cc::physics::TrimeshShape *)new cc::physics::TrimeshShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_TrimeshShape, __jsb_cc_physics_TrimeshShape_class, js_delete_cc_physics_TrimeshShape) + +static bool js_delete_cc_physics_TrimeshShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_TrimeshShape) + +static bool js_cc_physics_TrimeshShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_initialize) + +static bool js_cc_physics_TrimeshShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_onEnable) + +static bool js_cc_physics_TrimeshShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_onDisable) + +static bool js_cc_physics_TrimeshShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_onDestroy) + +static bool js_cc_physics_TrimeshShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setMaterial) + +static bool js_cc_physics_TrimeshShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setAsTrigger) + +static bool js_cc_physics_TrimeshShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setCenter) + +static bool js_cc_physics_TrimeshShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_updateEventListener) + +static bool js_cc_physics_TrimeshShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_TrimeshShape_getAABB) + +static bool js_cc_physics_TrimeshShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_TrimeshShape_getBoundingSphere) + +static bool js_cc_physics_TrimeshShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_getGroup) + +static bool js_cc_physics_TrimeshShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setGroup) + +static bool js_cc_physics_TrimeshShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_getMask) + +static bool js_cc_physics_TrimeshShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setMask) + +static bool js_cc_physics_TrimeshShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::TrimeshShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_getObjectID) + +static bool js_cc_physics_TrimeshShape_setMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMesh(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setMesh) + +static bool js_cc_physics_TrimeshShape_useConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useConvex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_useConvex) + +bool js_register_cc_physics_TrimeshShape(se::Object* obj) { + auto* cls = se::Class::create("TrimeshShape", obj, nullptr, _SE(js_new_cc_physics_TrimeshShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_TrimeshShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_TrimeshShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_TrimeshShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_TrimeshShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_TrimeshShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_TrimeshShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_TrimeshShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_TrimeshShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_TrimeshShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_TrimeshShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_TrimeshShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_TrimeshShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_TrimeshShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_TrimeshShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_TrimeshShape_getObjectID)); + cls->defineFunction("setMesh", _SE(js_cc_physics_TrimeshShape_setMesh)); + cls->defineFunction("useConvex", _SE(js_cc_physics_TrimeshShape_useConvex)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_TrimeshShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_TrimeshShape_proto = cls->getProto(); + __jsb_cc_physics_TrimeshShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_CylinderShape_class = nullptr; +se::Object* __jsb_cc_physics_CylinderShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_CylinderShape) + +static bool js_new_cc_physics_CylinderShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::CylinderShape *result; + result = (cc::physics::CylinderShape *)new cc::physics::CylinderShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_CylinderShape, __jsb_cc_physics_CylinderShape_class, js_delete_cc_physics_CylinderShape) + +static bool js_delete_cc_physics_CylinderShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_CylinderShape) + +static bool js_cc_physics_CylinderShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_initialize) + +static bool js_cc_physics_CylinderShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_onEnable) + +static bool js_cc_physics_CylinderShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_onDisable) + +static bool js_cc_physics_CylinderShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_onDestroy) + +static bool js_cc_physics_CylinderShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setMaterial) + +static bool js_cc_physics_CylinderShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setAsTrigger) + +static bool js_cc_physics_CylinderShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setCenter) + +static bool js_cc_physics_CylinderShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_updateEventListener) + +static bool js_cc_physics_CylinderShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_CylinderShape_getAABB) + +static bool js_cc_physics_CylinderShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_CylinderShape_getBoundingSphere) + +static bool js_cc_physics_CylinderShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_getGroup) + +static bool js_cc_physics_CylinderShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setGroup) + +static bool js_cc_physics_CylinderShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_getMask) + +static bool js_cc_physics_CylinderShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setMask) + +static bool js_cc_physics_CylinderShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::CylinderShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_getObjectID) + +static bool js_cc_physics_CylinderShape_setConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConvex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setConvex) + +static bool js_cc_physics_CylinderShape_setCylinder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + float arg2 ; + float arg3 ; + cc::physics::EAxisDirection arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCylinder(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setCylinder) + +bool js_register_cc_physics_CylinderShape(se::Object* obj) { + auto* cls = se::Class::create("CylinderShape", obj, nullptr, _SE(js_new_cc_physics_CylinderShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_CylinderShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_CylinderShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_CylinderShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_CylinderShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_CylinderShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_CylinderShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_CylinderShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_CylinderShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_CylinderShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_CylinderShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_CylinderShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_CylinderShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_CylinderShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_CylinderShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_CylinderShape_getObjectID)); + cls->defineFunction("setConvex", _SE(js_cc_physics_CylinderShape_setConvex)); + cls->defineFunction("setCylinder", _SE(js_cc_physics_CylinderShape_setCylinder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_CylinderShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_CylinderShape_proto = cls->getProto(); + __jsb_cc_physics_CylinderShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_ConeShape_class = nullptr; +se::Object* __jsb_cc_physics_ConeShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_ConeShape) + +static bool js_new_cc_physics_ConeShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::ConeShape *result; + result = (cc::physics::ConeShape *)new cc::physics::ConeShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_ConeShape, __jsb_cc_physics_ConeShape_class, js_delete_cc_physics_ConeShape) + +static bool js_delete_cc_physics_ConeShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_ConeShape) + +static bool js_cc_physics_ConeShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_initialize) + +static bool js_cc_physics_ConeShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_onEnable) + +static bool js_cc_physics_ConeShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_onDisable) + +static bool js_cc_physics_ConeShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_onDestroy) + +static bool js_cc_physics_ConeShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setMaterial) + +static bool js_cc_physics_ConeShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setAsTrigger) + +static bool js_cc_physics_ConeShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setCenter) + +static bool js_cc_physics_ConeShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_updateEventListener) + +static bool js_cc_physics_ConeShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_ConeShape_getAABB) + +static bool js_cc_physics_ConeShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_ConeShape_getBoundingSphere) + +static bool js_cc_physics_ConeShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_getGroup) + +static bool js_cc_physics_ConeShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setGroup) + +static bool js_cc_physics_ConeShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_getMask) + +static bool js_cc_physics_ConeShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setMask) + +static bool js_cc_physics_ConeShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::ConeShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_getObjectID) + +static bool js_cc_physics_ConeShape_setConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConvex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setConvex) + +static bool js_cc_physics_ConeShape_setCone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + float arg2 ; + float arg3 ; + cc::physics::EAxisDirection arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCone(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setCone) + +bool js_register_cc_physics_ConeShape(se::Object* obj) { + auto* cls = se::Class::create("ConeShape", obj, nullptr, _SE(js_new_cc_physics_ConeShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_ConeShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_ConeShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_ConeShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_ConeShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_ConeShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_ConeShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_ConeShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_ConeShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_ConeShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_ConeShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_ConeShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_ConeShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_ConeShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_ConeShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_ConeShape_getObjectID)); + cls->defineFunction("setConvex", _SE(js_cc_physics_ConeShape_setConvex)); + cls->defineFunction("setCone", _SE(js_cc_physics_ConeShape_setCone)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_ConeShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_ConeShape_proto = cls->getProto(); + __jsb_cc_physics_ConeShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_TerrainShape_class = nullptr; +se::Object* __jsb_cc_physics_TerrainShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_TerrainShape) + +static bool js_new_cc_physics_TerrainShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::TerrainShape *result; + result = (cc::physics::TerrainShape *)new cc::physics::TerrainShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_TerrainShape, __jsb_cc_physics_TerrainShape_class, js_delete_cc_physics_TerrainShape) + +static bool js_delete_cc_physics_TerrainShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_TerrainShape) + +static bool js_cc_physics_TerrainShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_initialize) + +static bool js_cc_physics_TerrainShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_onEnable) + +static bool js_cc_physics_TerrainShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_onDisable) + +static bool js_cc_physics_TerrainShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_onDestroy) + +static bool js_cc_physics_TerrainShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setMaterial) + +static bool js_cc_physics_TerrainShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setAsTrigger) + +static bool js_cc_physics_TerrainShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setCenter) + +static bool js_cc_physics_TerrainShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_updateEventListener) + +static bool js_cc_physics_TerrainShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_TerrainShape_getAABB) + +static bool js_cc_physics_TerrainShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_TerrainShape_getBoundingSphere) + +static bool js_cc_physics_TerrainShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_getGroup) + +static bool js_cc_physics_TerrainShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setGroup) + +static bool js_cc_physics_TerrainShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_getMask) + +static bool js_cc_physics_TerrainShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setMask) + +static bool js_cc_physics_TerrainShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::TerrainShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_getObjectID) + +static bool js_cc_physics_TerrainShape_setTerrain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setTerrain(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setTerrain) + +bool js_register_cc_physics_TerrainShape(se::Object* obj) { + auto* cls = se::Class::create("TerrainShape", obj, nullptr, _SE(js_new_cc_physics_TerrainShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_TerrainShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_TerrainShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_TerrainShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_TerrainShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_TerrainShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_TerrainShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_TerrainShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_TerrainShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_TerrainShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_TerrainShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_TerrainShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_TerrainShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_TerrainShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_TerrainShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_TerrainShape_getObjectID)); + cls->defineFunction("setTerrain", _SE(js_cc_physics_TerrainShape_setTerrain)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_TerrainShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_TerrainShape_proto = cls->getProto(); + __jsb_cc_physics_TerrainShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_RevoluteJoint_class = nullptr; +se::Object* __jsb_cc_physics_RevoluteJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_RevoluteJoint) + +static bool js_new_cc_physics_RevoluteJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::RevoluteJoint *result; + result = (cc::physics::RevoluteJoint *)new cc::physics::RevoluteJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_RevoluteJoint, __jsb_cc_physics_RevoluteJoint_class, js_delete_cc_physics_RevoluteJoint) + +static bool js_delete_cc_physics_RevoluteJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_RevoluteJoint) + +static bool js_cc_physics_RevoluteJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_initialize) + +static bool js_cc_physics_RevoluteJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_onEnable) + +static bool js_cc_physics_RevoluteJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_onDisable) + +static bool js_cc_physics_RevoluteJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_onDestroy) + +static bool js_cc_physics_RevoluteJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setEnableCollision) + +static bool js_cc_physics_RevoluteJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setConnectedBody) + +static bool js_cc_physics_RevoluteJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::RevoluteJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_getObjectID) + +static bool js_cc_physics_RevoluteJoint_setPivotA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotA(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setPivotA) + +static bool js_cc_physics_RevoluteJoint_setPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotB(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setPivotB) + +static bool js_cc_physics_RevoluteJoint_setAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAxis(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setAxis) + +static bool js_cc_physics_RevoluteJoint_setLimitEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLimitEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setLimitEnabled) + +static bool js_cc_physics_RevoluteJoint_setLowerLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLowerLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setLowerLimit) + +static bool js_cc_physics_RevoluteJoint_setUpperLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUpperLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setUpperLimit) + +static bool js_cc_physics_RevoluteJoint_setMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMotorEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setMotorEnabled) + +static bool js_cc_physics_RevoluteJoint_setMotorVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMotorVelocity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setMotorVelocity) + +static bool js_cc_physics_RevoluteJoint_setMotorForceLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMotorForceLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setMotorForceLimit) + +bool js_register_cc_physics_RevoluteJoint(se::Object* obj) { + auto* cls = se::Class::create("RevoluteJoint", obj, nullptr, _SE(js_new_cc_physics_RevoluteJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_RevoluteJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_RevoluteJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_RevoluteJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_RevoluteJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_RevoluteJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_RevoluteJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_RevoluteJoint_getObjectID)); + cls->defineFunction("setPivotA", _SE(js_cc_physics_RevoluteJoint_setPivotA)); + cls->defineFunction("setPivotB", _SE(js_cc_physics_RevoluteJoint_setPivotB)); + cls->defineFunction("setAxis", _SE(js_cc_physics_RevoluteJoint_setAxis)); + cls->defineFunction("setLimitEnabled", _SE(js_cc_physics_RevoluteJoint_setLimitEnabled)); + cls->defineFunction("setLowerLimit", _SE(js_cc_physics_RevoluteJoint_setLowerLimit)); + cls->defineFunction("setUpperLimit", _SE(js_cc_physics_RevoluteJoint_setUpperLimit)); + cls->defineFunction("setMotorEnabled", _SE(js_cc_physics_RevoluteJoint_setMotorEnabled)); + cls->defineFunction("setMotorVelocity", _SE(js_cc_physics_RevoluteJoint_setMotorVelocity)); + cls->defineFunction("setMotorForceLimit", _SE(js_cc_physics_RevoluteJoint_setMotorForceLimit)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_RevoluteJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_RevoluteJoint_proto = cls->getProto(); + __jsb_cc_physics_RevoluteJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_SphericalJoint_class = nullptr; +se::Object* __jsb_cc_physics_SphericalJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_SphericalJoint) + +static bool js_new_cc_physics_SphericalJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::SphericalJoint *result; + result = (cc::physics::SphericalJoint *)new cc::physics::SphericalJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_SphericalJoint, __jsb_cc_physics_SphericalJoint_class, js_delete_cc_physics_SphericalJoint) + +static bool js_delete_cc_physics_SphericalJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_SphericalJoint) + +static bool js_cc_physics_SphericalJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_initialize) + +static bool js_cc_physics_SphericalJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_onEnable) + +static bool js_cc_physics_SphericalJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_onDisable) + +static bool js_cc_physics_SphericalJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_onDestroy) + +static bool js_cc_physics_SphericalJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setEnableCollision) + +static bool js_cc_physics_SphericalJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setConnectedBody) + +static bool js_cc_physics_SphericalJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::SphericalJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_getObjectID) + +static bool js_cc_physics_SphericalJoint_setPivotA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotA(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setPivotA) + +static bool js_cc_physics_SphericalJoint_setPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotB(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setPivotB) + +bool js_register_cc_physics_SphericalJoint(se::Object* obj) { + auto* cls = se::Class::create("SphericalJoint", obj, nullptr, _SE(js_new_cc_physics_SphericalJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_SphericalJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_SphericalJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_SphericalJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_SphericalJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_SphericalJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_SphericalJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_SphericalJoint_getObjectID)); + cls->defineFunction("setPivotA", _SE(js_cc_physics_SphericalJoint_setPivotA)); + cls->defineFunction("setPivotB", _SE(js_cc_physics_SphericalJoint_setPivotB)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_SphericalJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_SphericalJoint_proto = cls->getProto(); + __jsb_cc_physics_SphericalJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_FixedJoint_class = nullptr; +se::Object* __jsb_cc_physics_FixedJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_FixedJoint) + +static bool js_new_cc_physics_FixedJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::FixedJoint *result; + result = (cc::physics::FixedJoint *)new cc::physics::FixedJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_FixedJoint, __jsb_cc_physics_FixedJoint_class, js_delete_cc_physics_FixedJoint) + +static bool js_delete_cc_physics_FixedJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_FixedJoint) + +static bool js_cc_physics_FixedJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_initialize) + +static bool js_cc_physics_FixedJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_onEnable) + +static bool js_cc_physics_FixedJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_onDisable) + +static bool js_cc_physics_FixedJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_onDestroy) + +static bool js_cc_physics_FixedJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setEnableCollision) + +static bool js_cc_physics_FixedJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setConnectedBody) + +static bool js_cc_physics_FixedJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::FixedJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_getObjectID) + +static bool js_cc_physics_FixedJoint_setBreakForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setBreakForce) + +static bool js_cc_physics_FixedJoint_setBreakTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setBreakTorque) + +bool js_register_cc_physics_FixedJoint(se::Object* obj) { + auto* cls = se::Class::create("FixedJoint", obj, nullptr, _SE(js_new_cc_physics_FixedJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_FixedJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_FixedJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_FixedJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_FixedJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_FixedJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_FixedJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_FixedJoint_getObjectID)); + cls->defineFunction("setBreakForce", _SE(js_cc_physics_FixedJoint_setBreakForce)); + cls->defineFunction("setBreakTorque", _SE(js_cc_physics_FixedJoint_setBreakTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_FixedJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_FixedJoint_proto = cls->getProto(); + __jsb_cc_physics_FixedJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_GenericJoint_class = nullptr; +se::Object* __jsb_cc_physics_GenericJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_GenericJoint) + +static bool js_new_cc_physics_GenericJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::GenericJoint *result; + result = (cc::physics::GenericJoint *)new cc::physics::GenericJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_GenericJoint, __jsb_cc_physics_GenericJoint_class, js_delete_cc_physics_GenericJoint) + +static bool js_delete_cc_physics_GenericJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_GenericJoint) + +static bool js_cc_physics_GenericJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_initialize) + +static bool js_cc_physics_GenericJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_onEnable) + +static bool js_cc_physics_GenericJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_onDisable) + +static bool js_cc_physics_GenericJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_onDestroy) + +static bool js_cc_physics_GenericJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setEnableCollision) + +static bool js_cc_physics_GenericJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setConnectedBody) + +static bool js_cc_physics_GenericJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::GenericJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_getObjectID) + +static bool js_cc_physics_GenericJoint_setConstraintMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setConstraintMode(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setConstraintMode) + +static bool js_cc_physics_GenericJoint_setLinearLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearLimit(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearLimit) + +static bool js_cc_physics_GenericJoint_setAngularExtent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularExtent(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularExtent) + +static bool js_cc_physics_GenericJoint_setLinearSoftConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearSoftConstraint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearSoftConstraint) + +static bool js_cc_physics_GenericJoint_setLinearStiffness(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearStiffness(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearStiffness) + +static bool js_cc_physics_GenericJoint_setLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearDamping) + +static bool js_cc_physics_GenericJoint_setLinearRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearRestitution) + +static bool js_cc_physics_GenericJoint_setSwingSoftConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingSoftConstraint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingSoftConstraint) + +static bool js_cc_physics_GenericJoint_setTwistSoftConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistSoftConstraint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistSoftConstraint) + +static bool js_cc_physics_GenericJoint_setSwingStiffness(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingStiffness(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingStiffness) + +static bool js_cc_physics_GenericJoint_setSwingDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingDamping) + +static bool js_cc_physics_GenericJoint_setSwingRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingRestitution) + +static bool js_cc_physics_GenericJoint_setTwistStiffness(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistStiffness(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistStiffness) + +static bool js_cc_physics_GenericJoint_setTwistDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistDamping) + +static bool js_cc_physics_GenericJoint_setTwistRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistRestitution) + +static bool js_cc_physics_GenericJoint_setDriverMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDriverMode(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setDriverMode) + +static bool js_cc_physics_GenericJoint_setLinearMotorTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearMotorTarget(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearMotorTarget) + +static bool js_cc_physics_GenericJoint_setLinearMotorVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearMotorVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearMotorVelocity) + +static bool js_cc_physics_GenericJoint_setLinearMotorForceLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearMotorForceLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearMotorForceLimit) + +static bool js_cc_physics_GenericJoint_setAngularMotorTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularMotorTarget(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularMotorTarget) + +static bool js_cc_physics_GenericJoint_setAngularMotorVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularMotorVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularMotorVelocity) + +static bool js_cc_physics_GenericJoint_setAngularMotorForceLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAngularMotorForceLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularMotorForceLimit) + +static bool js_cc_physics_GenericJoint_setPivotA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotA(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setPivotA) + +static bool js_cc_physics_GenericJoint_setPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotB(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setPivotB) + +static bool js_cc_physics_GenericJoint_setAutoPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAutoPivotB(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAutoPivotB) + +static bool js_cc_physics_GenericJoint_setAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAxis(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAxis) + +static bool js_cc_physics_GenericJoint_setSecondaryAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSecondaryAxis(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSecondaryAxis) + +static bool js_cc_physics_GenericJoint_setBreakForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setBreakForce) + +static bool js_cc_physics_GenericJoint_setBreakTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setBreakTorque) + +bool js_register_cc_physics_GenericJoint(se::Object* obj) { + auto* cls = se::Class::create("GenericJoint", obj, nullptr, _SE(js_new_cc_physics_GenericJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_GenericJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_GenericJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_GenericJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_GenericJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_GenericJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_GenericJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_GenericJoint_getObjectID)); + cls->defineFunction("setConstraintMode", _SE(js_cc_physics_GenericJoint_setConstraintMode)); + cls->defineFunction("setLinearLimit", _SE(js_cc_physics_GenericJoint_setLinearLimit)); + cls->defineFunction("setAngularExtent", _SE(js_cc_physics_GenericJoint_setAngularExtent)); + cls->defineFunction("setLinearSoftConstraint", _SE(js_cc_physics_GenericJoint_setLinearSoftConstraint)); + cls->defineFunction("setLinearStiffness", _SE(js_cc_physics_GenericJoint_setLinearStiffness)); + cls->defineFunction("setLinearDamping", _SE(js_cc_physics_GenericJoint_setLinearDamping)); + cls->defineFunction("setLinearRestitution", _SE(js_cc_physics_GenericJoint_setLinearRestitution)); + cls->defineFunction("setSwingSoftConstraint", _SE(js_cc_physics_GenericJoint_setSwingSoftConstraint)); + cls->defineFunction("setTwistSoftConstraint", _SE(js_cc_physics_GenericJoint_setTwistSoftConstraint)); + cls->defineFunction("setSwingStiffness", _SE(js_cc_physics_GenericJoint_setSwingStiffness)); + cls->defineFunction("setSwingDamping", _SE(js_cc_physics_GenericJoint_setSwingDamping)); + cls->defineFunction("setSwingRestitution", _SE(js_cc_physics_GenericJoint_setSwingRestitution)); + cls->defineFunction("setTwistStiffness", _SE(js_cc_physics_GenericJoint_setTwistStiffness)); + cls->defineFunction("setTwistDamping", _SE(js_cc_physics_GenericJoint_setTwistDamping)); + cls->defineFunction("setTwistRestitution", _SE(js_cc_physics_GenericJoint_setTwistRestitution)); + cls->defineFunction("setDriverMode", _SE(js_cc_physics_GenericJoint_setDriverMode)); + cls->defineFunction("setLinearMotorTarget", _SE(js_cc_physics_GenericJoint_setLinearMotorTarget)); + cls->defineFunction("setLinearMotorVelocity", _SE(js_cc_physics_GenericJoint_setLinearMotorVelocity)); + cls->defineFunction("setLinearMotorForceLimit", _SE(js_cc_physics_GenericJoint_setLinearMotorForceLimit)); + cls->defineFunction("setAngularMotorTarget", _SE(js_cc_physics_GenericJoint_setAngularMotorTarget)); + cls->defineFunction("setAngularMotorVelocity", _SE(js_cc_physics_GenericJoint_setAngularMotorVelocity)); + cls->defineFunction("setAngularMotorForceLimit", _SE(js_cc_physics_GenericJoint_setAngularMotorForceLimit)); + cls->defineFunction("setPivotA", _SE(js_cc_physics_GenericJoint_setPivotA)); + cls->defineFunction("setPivotB", _SE(js_cc_physics_GenericJoint_setPivotB)); + cls->defineFunction("setAutoPivotB", _SE(js_cc_physics_GenericJoint_setAutoPivotB)); + cls->defineFunction("setAxis", _SE(js_cc_physics_GenericJoint_setAxis)); + cls->defineFunction("setSecondaryAxis", _SE(js_cc_physics_GenericJoint_setSecondaryAxis)); + cls->defineFunction("setBreakForce", _SE(js_cc_physics_GenericJoint_setBreakForce)); + cls->defineFunction("setBreakTorque", _SE(js_cc_physics_GenericJoint_setBreakTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_GenericJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_GenericJoint_proto = cls->getProto(); + __jsb_cc_physics_GenericJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_CapsuleCharacterController_class = nullptr; +se::Object* __jsb_cc_physics_CapsuleCharacterController_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_CapsuleCharacterController) + +static bool js_new_cc_physics_CapsuleCharacterController(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::CapsuleCharacterController *result; + result = (cc::physics::CapsuleCharacterController *)new cc::physics::CapsuleCharacterController(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_CapsuleCharacterController, __jsb_cc_physics_CapsuleCharacterController_class, js_delete_cc_physics_CapsuleCharacterController) + +static bool js_delete_cc_physics_CapsuleCharacterController(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_CapsuleCharacterController) + +static bool js_cc_physics_CapsuleCharacterController_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_initialize) + +static bool js_cc_physics_CapsuleCharacterController_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onEnable) + +static bool js_cc_physics_CapsuleCharacterController_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onDisable) + +static bool js_cc_physics_CapsuleCharacterController_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onDestroy) + +static bool js_cc_physics_CapsuleCharacterController_getPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getPosition(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getPosition) + +static bool js_cc_physics_CapsuleCharacterController_setPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPosition(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setPosition) + +static bool js_cc_physics_CapsuleCharacterController_onGround(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onGround(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onGround) + +static bool js_cc_physics_CapsuleCharacterController_move(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->move(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_move) + +static bool js_cc_physics_CapsuleCharacterController_syncPhysicsToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncPhysicsToScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_syncPhysicsToScene) + +static bool js_cc_physics_CapsuleCharacterController_setStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setStepOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setStepOffset) + +static bool js_cc_physics_CapsuleCharacterController_getStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getStepOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getStepOffset) + +static bool js_cc_physics_CapsuleCharacterController_setSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSlopeLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setSlopeLimit) + +static bool js_cc_physics_CapsuleCharacterController_getSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getSlopeLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getSlopeLimit) + +static bool js_cc_physics_CapsuleCharacterController_setContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setContactOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setContactOffset) + +static bool js_cc_physics_CapsuleCharacterController_getContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getContactOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getContactOffset) + +static bool js_cc_physics_CapsuleCharacterController_setDetectCollisions(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDetectCollisions(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setDetectCollisions) + +static bool js_cc_physics_CapsuleCharacterController_setOverlapRecovery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOverlapRecovery(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setOverlapRecovery) + +static bool js_cc_physics_CapsuleCharacterController_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setCenter) + +static bool js_cc_physics_CapsuleCharacterController_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getGroup) + +static bool js_cc_physics_CapsuleCharacterController_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setGroup) + +static bool js_cc_physics_CapsuleCharacterController_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getMask) + +static bool js_cc_physics_CapsuleCharacterController_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setMask) + +static bool js_cc_physics_CapsuleCharacterController_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_updateEventListener) + +static bool js_cc_physics_CapsuleCharacterController_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::CapsuleCharacterController const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getObjectID) + +static bool js_cc_physics_CapsuleCharacterController_setRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setRadius) + +static bool js_cc_physics_CapsuleCharacterController_setHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setHeight) + +bool js_register_cc_physics_CapsuleCharacterController(se::Object* obj) { + auto* cls = se::Class::create("CapsuleCharacterController", obj, nullptr, _SE(js_new_cc_physics_CapsuleCharacterController)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_CapsuleCharacterController_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_CapsuleCharacterController_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_CapsuleCharacterController_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_CapsuleCharacterController_onDestroy)); + cls->defineFunction("getPosition", _SE(js_cc_physics_CapsuleCharacterController_getPosition)); + cls->defineFunction("setPosition", _SE(js_cc_physics_CapsuleCharacterController_setPosition)); + cls->defineFunction("onGround", _SE(js_cc_physics_CapsuleCharacterController_onGround)); + cls->defineFunction("move", _SE(js_cc_physics_CapsuleCharacterController_move)); + cls->defineFunction("syncPhysicsToScene", _SE(js_cc_physics_CapsuleCharacterController_syncPhysicsToScene)); + cls->defineFunction("setStepOffset", _SE(js_cc_physics_CapsuleCharacterController_setStepOffset)); + cls->defineFunction("getStepOffset", _SE(js_cc_physics_CapsuleCharacterController_getStepOffset)); + cls->defineFunction("setSlopeLimit", _SE(js_cc_physics_CapsuleCharacterController_setSlopeLimit)); + cls->defineFunction("getSlopeLimit", _SE(js_cc_physics_CapsuleCharacterController_getSlopeLimit)); + cls->defineFunction("setContactOffset", _SE(js_cc_physics_CapsuleCharacterController_setContactOffset)); + cls->defineFunction("getContactOffset", _SE(js_cc_physics_CapsuleCharacterController_getContactOffset)); + cls->defineFunction("setDetectCollisions", _SE(js_cc_physics_CapsuleCharacterController_setDetectCollisions)); + cls->defineFunction("setOverlapRecovery", _SE(js_cc_physics_CapsuleCharacterController_setOverlapRecovery)); + cls->defineFunction("setCenter", _SE(js_cc_physics_CapsuleCharacterController_setCenter)); + cls->defineFunction("getGroup", _SE(js_cc_physics_CapsuleCharacterController_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_CapsuleCharacterController_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_CapsuleCharacterController_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_CapsuleCharacterController_setMask)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_CapsuleCharacterController_updateEventListener)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_CapsuleCharacterController_getObjectID)); + cls->defineFunction("setRadius", _SE(js_cc_physics_CapsuleCharacterController_setRadius)); + cls->defineFunction("setHeight", _SE(js_cc_physics_CapsuleCharacterController_setHeight)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_CapsuleCharacterController)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_CapsuleCharacterController_proto = cls->getProto(); + __jsb_cc_physics_CapsuleCharacterController_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_BoxCharacterController_class = nullptr; +se::Object* __jsb_cc_physics_BoxCharacterController_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_BoxCharacterController) + +static bool js_new_cc_physics_BoxCharacterController(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::BoxCharacterController *result; + result = (cc::physics::BoxCharacterController *)new cc::physics::BoxCharacterController(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_BoxCharacterController, __jsb_cc_physics_BoxCharacterController_class, js_delete_cc_physics_BoxCharacterController) + +static bool js_delete_cc_physics_BoxCharacterController(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_BoxCharacterController) + +static bool js_cc_physics_BoxCharacterController_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_initialize) + +static bool js_cc_physics_BoxCharacterController_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onEnable) + +static bool js_cc_physics_BoxCharacterController_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onDisable) + +static bool js_cc_physics_BoxCharacterController_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onDestroy) + +static bool js_cc_physics_BoxCharacterController_getPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getPosition(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getPosition) + +static bool js_cc_physics_BoxCharacterController_setPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPosition(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setPosition) + +static bool js_cc_physics_BoxCharacterController_onGround(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onGround(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onGround) + +static bool js_cc_physics_BoxCharacterController_move(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->move(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_move) + +static bool js_cc_physics_BoxCharacterController_syncPhysicsToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncPhysicsToScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_syncPhysicsToScene) + +static bool js_cc_physics_BoxCharacterController_setStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setStepOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setStepOffset) + +static bool js_cc_physics_BoxCharacterController_getStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getStepOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getStepOffset) + +static bool js_cc_physics_BoxCharacterController_setSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSlopeLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setSlopeLimit) + +static bool js_cc_physics_BoxCharacterController_getSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getSlopeLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getSlopeLimit) + +static bool js_cc_physics_BoxCharacterController_setContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setContactOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setContactOffset) + +static bool js_cc_physics_BoxCharacterController_getContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getContactOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getContactOffset) + +static bool js_cc_physics_BoxCharacterController_setDetectCollisions(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDetectCollisions(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setDetectCollisions) + +static bool js_cc_physics_BoxCharacterController_setOverlapRecovery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOverlapRecovery(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setOverlapRecovery) + +static bool js_cc_physics_BoxCharacterController_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setCenter) + +static bool js_cc_physics_BoxCharacterController_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getGroup) + +static bool js_cc_physics_BoxCharacterController_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setGroup) + +static bool js_cc_physics_BoxCharacterController_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getMask) + +static bool js_cc_physics_BoxCharacterController_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setMask) + +static bool js_cc_physics_BoxCharacterController_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_updateEventListener) + +static bool js_cc_physics_BoxCharacterController_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::BoxCharacterController const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getObjectID) + +static bool js_cc_physics_BoxCharacterController_setHalfHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHalfHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setHalfHeight) + +static bool js_cc_physics_BoxCharacterController_setHalfSideExtent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHalfSideExtent(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setHalfSideExtent) + +static bool js_cc_physics_BoxCharacterController_setHalfForwardExtent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHalfForwardExtent(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setHalfForwardExtent) + +bool js_register_cc_physics_BoxCharacterController(se::Object* obj) { + auto* cls = se::Class::create("BoxCharacterController", obj, nullptr, _SE(js_new_cc_physics_BoxCharacterController)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_BoxCharacterController_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_BoxCharacterController_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_BoxCharacterController_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_BoxCharacterController_onDestroy)); + cls->defineFunction("getPosition", _SE(js_cc_physics_BoxCharacterController_getPosition)); + cls->defineFunction("setPosition", _SE(js_cc_physics_BoxCharacterController_setPosition)); + cls->defineFunction("onGround", _SE(js_cc_physics_BoxCharacterController_onGround)); + cls->defineFunction("move", _SE(js_cc_physics_BoxCharacterController_move)); + cls->defineFunction("syncPhysicsToScene", _SE(js_cc_physics_BoxCharacterController_syncPhysicsToScene)); + cls->defineFunction("setStepOffset", _SE(js_cc_physics_BoxCharacterController_setStepOffset)); + cls->defineFunction("getStepOffset", _SE(js_cc_physics_BoxCharacterController_getStepOffset)); + cls->defineFunction("setSlopeLimit", _SE(js_cc_physics_BoxCharacterController_setSlopeLimit)); + cls->defineFunction("getSlopeLimit", _SE(js_cc_physics_BoxCharacterController_getSlopeLimit)); + cls->defineFunction("setContactOffset", _SE(js_cc_physics_BoxCharacterController_setContactOffset)); + cls->defineFunction("getContactOffset", _SE(js_cc_physics_BoxCharacterController_getContactOffset)); + cls->defineFunction("setDetectCollisions", _SE(js_cc_physics_BoxCharacterController_setDetectCollisions)); + cls->defineFunction("setOverlapRecovery", _SE(js_cc_physics_BoxCharacterController_setOverlapRecovery)); + cls->defineFunction("setCenter", _SE(js_cc_physics_BoxCharacterController_setCenter)); + cls->defineFunction("getGroup", _SE(js_cc_physics_BoxCharacterController_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_BoxCharacterController_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_BoxCharacterController_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_BoxCharacterController_setMask)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_BoxCharacterController_updateEventListener)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_BoxCharacterController_getObjectID)); + cls->defineFunction("setHalfHeight", _SE(js_cc_physics_BoxCharacterController_setHalfHeight)); + cls->defineFunction("setHalfSideExtent", _SE(js_cc_physics_BoxCharacterController_setHalfSideExtent)); + cls->defineFunction("setHalfForwardExtent", _SE(js_cc_physics_BoxCharacterController_setHalfForwardExtent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_BoxCharacterController)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_BoxCharacterController_proto = cls->getProto(); + __jsb_cc_physics_BoxCharacterController_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_physics(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb.physics", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb.physics", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_physics_World(ns); + js_register_cc_physics_RigidBody(ns); + js_register_cc_physics_SphereShape(ns); + js_register_cc_physics_BoxShape(ns); + js_register_cc_physics_CapsuleShape(ns); + js_register_cc_physics_PlaneShape(ns); + js_register_cc_physics_TrimeshShape(ns); + js_register_cc_physics_CylinderShape(ns); + js_register_cc_physics_ConeShape(ns); + js_register_cc_physics_TerrainShape(ns); + js_register_cc_physics_RevoluteJoint(ns); + js_register_cc_physics_SphericalJoint(ns); + js_register_cc_physics_FixedJoint(ns); + js_register_cc_physics_GenericJoint(ns); + js_register_cc_physics_CapsuleCharacterController(ns); + js_register_cc_physics_BoxCharacterController(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_physics_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_physics_auto.h new file mode 100644 index 0000000000..049e8d5469 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_physics_auto.h @@ -0,0 +1,125 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "physics/PhysicsSDK.h" +#include "bindings/auto/jsb_scene_auto.h" + + + +bool register_all_physics(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::World); +extern se::Object *__jsb_cc_physics_World_proto; // NOLINT +extern se::Class * __jsb_cc_physics_World_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::RigidBody); +extern se::Object *__jsb_cc_physics_RigidBody_proto; // NOLINT +extern se::Class * __jsb_cc_physics_RigidBody_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::SphereShape); +extern se::Object *__jsb_cc_physics_SphereShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_SphereShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::BoxShape); +extern se::Object *__jsb_cc_physics_BoxShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_BoxShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::CapsuleShape); +extern se::Object *__jsb_cc_physics_CapsuleShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_CapsuleShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::PlaneShape); +extern se::Object *__jsb_cc_physics_PlaneShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_PlaneShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::TrimeshShape); +extern se::Object *__jsb_cc_physics_TrimeshShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_TrimeshShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::CylinderShape); +extern se::Object *__jsb_cc_physics_CylinderShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_CylinderShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::ConeShape); +extern se::Object *__jsb_cc_physics_ConeShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_ConeShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::TerrainShape); +extern se::Object *__jsb_cc_physics_TerrainShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_TerrainShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::RevoluteJoint); +extern se::Object *__jsb_cc_physics_RevoluteJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_RevoluteJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::SphericalJoint); +extern se::Object *__jsb_cc_physics_SphericalJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_SphericalJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::FixedJoint); +extern se::Object *__jsb_cc_physics_FixedJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_FixedJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::GenericJoint); +extern se::Object *__jsb_cc_physics_GenericJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_GenericJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::CapsuleCharacterController); +extern se::Object *__jsb_cc_physics_CapsuleCharacterController_proto; // NOLINT +extern se::Class * __jsb_cc_physics_CapsuleCharacterController_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::BoxCharacterController); +extern se::Object *__jsb_cc_physics_BoxCharacterController_proto; // NOLINT +extern se::Class * __jsb_cc_physics_BoxCharacterController_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_pipeline_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_pipeline_auto.cpp new file mode 100644 index 0000000000..2a13acd513 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_pipeline_auto.cpp @@ -0,0 +1,19556 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_pipeline_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "renderer/pipeline/PipelineUBO.h" + +using namespace cc; + + +#define cc_pipeline_RenderPipeline_globalDSManager_get(self_) self_->getGlobalDSManager() + + +#define cc_pipeline_RenderPipeline_descriptorSet_get(self_) self_->getDescriptorSet() + + +#define cc_pipeline_RenderPipeline_descriptorSetLayout_get(self_) self_->getDescriptorSetLayout() + + +#define cc_pipeline_RenderPipeline_constantMacros_get(self_) self_->getConstantMacros() + + +#define cc_pipeline_RenderPipeline_clusterEnabled_get(self_) self_->isClusterEnabled() +#define cc_pipeline_RenderPipeline_clusterEnabled_set(self_, val_) self_->setClusterEnabled(val_) + + +#define cc_pipeline_RenderPipeline_bloomEnabled_get(self_) self_->isBloomEnabled() +#define cc_pipeline_RenderPipeline_bloomEnabled_set(self_, val_) self_->setBloomEnabled(val_) + + +#define cc_pipeline_RenderPipeline_pipelineSceneData_get(self_) self_->getPipelineSceneData() + + +#define cc_pipeline_RenderPipeline_geometryRenderer_get(self_) self_->getGeometryRenderer() + + +#define cc_pipeline_RenderPipeline_profiler_get(self_) self_->getProfiler() +#define cc_pipeline_RenderPipeline_profiler_set(self_, val_) self_->setProfiler(val_) + + +#define cc_pipeline_RenderPipeline_shadingScale_get(self_) self_->getShadingScale() +#define cc_pipeline_RenderPipeline_shadingScale_set(self_, val_) self_->setShadingScale(val_) + + +#define cc_pipeline_RenderPipeline__tag_get(self_) self_->getTag() +#define cc_pipeline_RenderPipeline__tag_set(self_, val_) self_->setTag(val_) + + +#define cc_pipeline_RenderPipeline__flows_get(self_) self_->getFlows() +#define cc_pipeline_RenderPipeline__flows_set(self_, val_) self_->setFlows(val_) + + +#define cc_pipeline_PipelineSceneData_isHDR_get(self_) self_->isHDR() +#define cc_pipeline_PipelineSceneData_isHDR_set(self_, val_) self_->setHDR(val_) + + +#define cc_pipeline_PipelineSceneData_shadingScale_get(self_) self_->getShadingScale() +#define cc_pipeline_PipelineSceneData_shadingScale_set(self_, val_) self_->setShadingScale(val_) + + +#define cc_pipeline_PipelineSceneData_fog_get(self_) self_->getFog() + + +#define cc_pipeline_PipelineSceneData_ambient_get(self_) self_->getAmbient() + + +#define cc_pipeline_PipelineSceneData_skybox_get(self_) self_->getSkybox() + + +#define cc_pipeline_PipelineSceneData_shadows_get(self_) self_->getShadows() + + +#define cc_pipeline_PipelineSceneData_skin_get(self_) self_->getSkin() + + +#define cc_pipeline_PipelineSceneData_postSettings_get(self_) self_->getPostSettings() + + +#define cc_pipeline_PipelineSceneData_lightProbes_get(self_) self_->getLightProbes() + + +#define cc_pipeline_PipelineSceneData_validPunctualLights_get(self_) self_->getValidPunctualLights() +#define cc_pipeline_PipelineSceneData_validPunctualLights_set(self_, val_) self_->setValidPunctualLights(val_) + + +#define cc_pipeline_PipelineSceneData_csmSupported_get(self_) self_->getCSMSupported() + + +#define cc_pipeline_PipelineSceneData_standardSkinModel_get(self_) self_->getStandardSkinModel() +#define cc_pipeline_PipelineSceneData_standardSkinModel_set(self_, val_) self_->setStandardSkinModel(val_) + + +#define cc_pipeline_PipelineSceneData_skinMaterialModel_get(self_) self_->getSkinMaterialModel() +#define cc_pipeline_PipelineSceneData_skinMaterialModel_set(self_, val_) self_->setSkinMaterialModel(val_) + + +#define cc_pipeline_RenderStage__name_get(self_) self_->getName() +#define cc_pipeline_RenderStage__name_set(self_, val_) self_->setName(val_) + + +#define cc_pipeline_RenderStage__priority_get(self_) self_->getPriority() +#define cc_pipeline_RenderStage__priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_pipeline_RenderStage__tag_get(self_) self_->getTag() +#define cc_pipeline_RenderStage__tag_set(self_, val_) self_->setTag(val_) + + +#define cc_pipeline_BloomStage_threshold_get(self_) self_->getThreshold() +#define cc_pipeline_BloomStage_threshold_set(self_, val_) self_->setThreshold(val_) + + +#define cc_pipeline_BloomStage_intensity_get(self_) self_->getIntensity() +#define cc_pipeline_BloomStage_intensity_set(self_, val_) self_->setIntensity(val_) + + +#define cc_pipeline_BloomStage_iterations_get(self_) self_->getIterations() +#define cc_pipeline_BloomStage_iterations_set(self_, val_) self_->setIterations(val_) + + +#define cc_pipeline_RenderFlow__name_get(self_) self_->getName() +#define cc_pipeline_RenderFlow__name_set(self_, val_) self_->setName(val_) + + +#define cc_pipeline_RenderFlow__priority_get(self_) self_->getPriority() +#define cc_pipeline_RenderFlow__priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_pipeline_RenderFlow__tag_get(self_) self_->getTag() +#define cc_pipeline_RenderFlow__tag_set(self_, val_) self_->setTag(val_) + + +#define cc_pipeline_RenderFlow__stages_get(self_) self_->getStages() +#define cc_pipeline_RenderFlow__stages_set(self_, val_) self_->setStages(val_) + + +#define cc_pipeline_DebugView_singleMode_get(self_) self_->getSingleMode() +#define cc_pipeline_DebugView_singleMode_set(self_, val_) self_->setSingleMode(val_) + + +#define cc_pipeline_DebugView_lightingWithAlbedo_get(self_) self_->isLightingWithAlbedo() +#define cc_pipeline_DebugView_lightingWithAlbedo_set(self_, val_) self_->setLightingWithAlbedo(val_) + + +#define cc_pipeline_DebugView_csmLayerColoration_get(self_) self_->isCsmLayerColoration() +#define cc_pipeline_DebugView_csmLayerColoration_set(self_, val_) self_->setCsmLayerColoration(val_) + + + +se::Class* __jsb_cc_pipeline_SkinningJointCapacity_class = nullptr; +se::Object* __jsb_cc_pipeline_SkinningJointCapacity_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SkinningJointCapacity) + +static bool js_new_cc_pipeline_SkinningJointCapacity(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SkinningJointCapacity *result; + result = (cc::pipeline::SkinningJointCapacity *)new cc::pipeline::SkinningJointCapacity(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SkinningJointCapacity, __jsb_cc_pipeline_SkinningJointCapacity_class, js_delete_cc_pipeline_SkinningJointCapacity) + +static bool js_delete_cc_pipeline_SkinningJointCapacity(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SkinningJointCapacity) + +bool js_register_cc_pipeline_SkinningJointCapacity(se::Object* obj) { + auto* cls = se::Class::create("SkinningJointCapacity", obj, nullptr, _SE(js_new_cc_pipeline_SkinningJointCapacity)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SkinningJointCapacity)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SkinningJointCapacity_proto = cls->getProto(); + __jsb_cc_pipeline_SkinningJointCapacity_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderObject_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderObject) + +static bool js_cc_pipeline_RenderObject_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderObject_depth_set) + +static bool js_cc_pipeline_RenderObject_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderObject_depth_get) + +static bool js_cc_pipeline_RenderObject_model_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->model, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderObject_model_set) + +static bool js_cc_pipeline_RenderObject_model_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->model, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->model, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderObject_model_get) + +static bool js_new_cc_pipeline_RenderObject(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderObject *result; + result = (cc::pipeline::RenderObject *)new cc::pipeline::RenderObject(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderObject, __jsb_cc_pipeline_RenderObject_class, js_delete_cc_pipeline_RenderObject) + +static bool js_delete_cc_pipeline_RenderObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderObject) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderObject * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + json->getProperty("model", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->model), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderObject(se::Object* obj) { + auto* cls = se::Class::create("RenderObject", obj, nullptr, _SE(js_new_cc_pipeline_RenderObject)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("depth", _SE(js_cc_pipeline_RenderObject_depth_get), _SE(js_cc_pipeline_RenderObject_depth_set)); + cls->defineProperty("model", _SE(js_cc_pipeline_RenderObject_model_get), _SE(js_cc_pipeline_RenderObject_model_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderObject_proto = cls->getProto(); + __jsb_cc_pipeline_RenderObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderTargetInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderTargetInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTargetInfo) + +static bool js_cc_pipeline_RenderTargetInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTargetInfo_width_set) + +static bool js_cc_pipeline_RenderTargetInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTargetInfo_width_get) + +static bool js_cc_pipeline_RenderTargetInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTargetInfo_height_set) + +static bool js_cc_pipeline_RenderTargetInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTargetInfo_height_get) + +static bool js_new_cc_pipeline_RenderTargetInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderTargetInfo *result; + result = (cc::pipeline::RenderTargetInfo *)new cc::pipeline::RenderTargetInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderTargetInfo, __jsb_cc_pipeline_RenderTargetInfo_class, js_delete_cc_pipeline_RenderTargetInfo) + +static bool js_delete_cc_pipeline_RenderTargetInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTargetInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTargetInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderTargetInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderTargetInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderTargetInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_pipeline_RenderTargetInfo_width_get), _SE(js_cc_pipeline_RenderTargetInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_pipeline_RenderTargetInfo_height_get), _SE(js_cc_pipeline_RenderTargetInfo_height_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderTargetInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderTargetInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderTargetInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderPass_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPass_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPass) + +static bool js_cc_pipeline_RenderPass_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_priority_set) + +static bool js_cc_pipeline_RenderPass_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_priority_get) + +static bool js_cc_pipeline_RenderPass_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_hash_set) + +static bool js_cc_pipeline_RenderPass_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hash, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_hash_get) + +static bool js_cc_pipeline_RenderPass_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_depth_set) + +static bool js_cc_pipeline_RenderPass_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_depth_get) + +static bool js_cc_pipeline_RenderPass_shaderID_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shaderID, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_shaderID_set) + +static bool js_cc_pipeline_RenderPass_shaderID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shaderID, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_shaderID_get) + +static bool js_cc_pipeline_RenderPass_passIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_passIndex_set) + +static bool js_cc_pipeline_RenderPass_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_passIndex_get) + +static bool js_cc_pipeline_RenderPass_subModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subModel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_subModel_set) + +static bool js_cc_pipeline_RenderPass_subModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subModel, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subModel, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_subModel_get) + +static bool js_new_cc_pipeline_RenderPass(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPass *result; + result = (cc::pipeline::RenderPass *)new cc::pipeline::RenderPass(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPass, __jsb_cc_pipeline_RenderPass_class, js_delete_cc_pipeline_RenderPass) + +static bool js_delete_cc_pipeline_RenderPass(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPass) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPass * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("hash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hash), ctx); + } + + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + json->getProperty("shaderID", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shaderID), ctx); + } + + + json->getProperty("passIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passIndex), ctx); + } + + + json->getProperty("subModel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subModel), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderPass(se::Object* obj) { + auto* cls = se::Class::create("RenderPass", obj, nullptr, _SE(js_new_cc_pipeline_RenderPass)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("priority", _SE(js_cc_pipeline_RenderPass_priority_get), _SE(js_cc_pipeline_RenderPass_priority_set)); + cls->defineProperty("hash", _SE(js_cc_pipeline_RenderPass_hash_get), _SE(js_cc_pipeline_RenderPass_hash_set)); + cls->defineProperty("depth", _SE(js_cc_pipeline_RenderPass_depth_get), _SE(js_cc_pipeline_RenderPass_depth_set)); + cls->defineProperty("shaderID", _SE(js_cc_pipeline_RenderPass_shaderID_get), _SE(js_cc_pipeline_RenderPass_shaderID_set)); + cls->defineProperty("passIndex", _SE(js_cc_pipeline_RenderPass_passIndex_get), _SE(js_cc_pipeline_RenderPass_passIndex_set)); + cls->defineProperty("subModel", _SE(js_cc_pipeline_RenderPass_subModel_get), _SE(js_cc_pipeline_RenderPass_subModel_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPass)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPass_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPass_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderPassDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPassDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPassDesc) + +static bool js_cc_pipeline_RenderPassDesc_index_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->index, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPassDesc_index_set) + +static bool js_cc_pipeline_RenderPassDesc_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->index, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPassDesc_index_get) + +static bool js_cc_pipeline_RenderPassDesc_colorAttachments_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorAttachments, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPassDesc_colorAttachments_set) + +static bool js_cc_pipeline_RenderPassDesc_colorAttachments_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorAttachments, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorAttachments, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPassDesc_colorAttachments_get) + +static bool js_cc_pipeline_RenderPassDesc_depthStencilAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilAttachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_set) + +static bool js_cc_pipeline_RenderPassDesc_depthStencilAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilAttachment, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilAttachment, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_get) + +static bool js_new_cc_pipeline_RenderPassDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPassDesc *result; + result = (cc::pipeline::RenderPassDesc *)new cc::pipeline::RenderPassDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPassDesc, __jsb_cc_pipeline_RenderPassDesc_class, js_delete_cc_pipeline_RenderPassDesc) + +static bool js_delete_cc_pipeline_RenderPassDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPassDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPassDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("index", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->index), ctx); + } + + + json->getProperty("colorAttachments", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorAttachments), ctx); + } + + + json->getProperty("depthStencilAttachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilAttachment), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderPassDesc(se::Object* obj) { + auto* cls = se::Class::create("RenderPassDesc", obj, nullptr, _SE(js_new_cc_pipeline_RenderPassDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("index", _SE(js_cc_pipeline_RenderPassDesc_index_get), _SE(js_cc_pipeline_RenderPassDesc_index_set)); + cls->defineProperty("colorAttachments", _SE(js_cc_pipeline_RenderPassDesc_colorAttachments_get), _SE(js_cc_pipeline_RenderPassDesc_colorAttachments_set)); + cls->defineProperty("depthStencilAttachment", _SE(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_get), _SE(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPassDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPassDesc_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPassDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderTextureDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderTextureDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTextureDesc) + +static bool js_cc_pipeline_RenderTextureDesc_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_name_set) + +static bool js_cc_pipeline_RenderTextureDesc_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_name_get) + +static bool js_cc_pipeline_RenderTextureDesc_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_type_set) + +static bool js_cc_pipeline_RenderTextureDesc_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_type_get) + +static bool js_cc_pipeline_RenderTextureDesc_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_usage_set) + +static bool js_cc_pipeline_RenderTextureDesc_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_usage_get) + +static bool js_cc_pipeline_RenderTextureDesc_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_format_set) + +static bool js_cc_pipeline_RenderTextureDesc_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_format_get) + +static bool js_cc_pipeline_RenderTextureDesc_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_width_set) + +static bool js_cc_pipeline_RenderTextureDesc_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_width_get) + +static bool js_cc_pipeline_RenderTextureDesc_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_height_set) + +static bool js_cc_pipeline_RenderTextureDesc_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_height_get) + +static bool js_new_cc_pipeline_RenderTextureDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderTextureDesc *result; + result = (cc::pipeline::RenderTextureDesc *)new cc::pipeline::RenderTextureDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderTextureDesc, __jsb_cc_pipeline_RenderTextureDesc_class, js_delete_cc_pipeline_RenderTextureDesc) + +static bool js_delete_cc_pipeline_RenderTextureDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTextureDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTextureDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderTextureDesc(se::Object* obj) { + auto* cls = se::Class::create("RenderTextureDesc", obj, nullptr, _SE(js_new_cc_pipeline_RenderTextureDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_RenderTextureDesc_name_get), _SE(js_cc_pipeline_RenderTextureDesc_name_set)); + cls->defineProperty("type", _SE(js_cc_pipeline_RenderTextureDesc_type_get), _SE(js_cc_pipeline_RenderTextureDesc_type_set)); + cls->defineProperty("usage", _SE(js_cc_pipeline_RenderTextureDesc_usage_get), _SE(js_cc_pipeline_RenderTextureDesc_usage_set)); + cls->defineProperty("format", _SE(js_cc_pipeline_RenderTextureDesc_format_get), _SE(js_cc_pipeline_RenderTextureDesc_format_set)); + cls->defineProperty("width", _SE(js_cc_pipeline_RenderTextureDesc_width_get), _SE(js_cc_pipeline_RenderTextureDesc_width_set)); + cls->defineProperty("height", _SE(js_cc_pipeline_RenderTextureDesc_height_get), _SE(js_cc_pipeline_RenderTextureDesc_height_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderTextureDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderTextureDesc_proto = cls->getProto(); + __jsb_cc_pipeline_RenderTextureDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_FrameBufferDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_FrameBufferDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_FrameBufferDesc) + +static bool js_cc_pipeline_FrameBufferDesc_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_name_set) + +static bool js_cc_pipeline_FrameBufferDesc_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_name_get) + +static bool js_cc_pipeline_FrameBufferDesc_renderPass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_renderPass_set) + +static bool js_cc_pipeline_FrameBufferDesc_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_renderPass_get) + +static bool js_cc_pipeline_FrameBufferDesc_colorTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_colorTextures_set) + +static bool js_cc_pipeline_FrameBufferDesc_colorTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_colorTextures_get) + +static bool js_cc_pipeline_FrameBufferDesc_depthStencilTexture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilTexture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_set) + +static bool js_cc_pipeline_FrameBufferDesc_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilTexture, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilTexture, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_get) + +static bool js_new_cc_pipeline_FrameBufferDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::FrameBufferDesc *result; + result = (cc::pipeline::FrameBufferDesc *)new cc::pipeline::FrameBufferDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_FrameBufferDesc, __jsb_cc_pipeline_FrameBufferDesc_class, js_delete_cc_pipeline_FrameBufferDesc) + +static bool js_delete_cc_pipeline_FrameBufferDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_FrameBufferDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::FrameBufferDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("renderPass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPass), ctx); + } + + + json->getProperty("colorTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorTextures), ctx); + } + + + json->getProperty("depthStencilTexture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilTexture), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_FrameBufferDesc(se::Object* obj) { + auto* cls = se::Class::create("FrameBufferDesc", obj, nullptr, _SE(js_new_cc_pipeline_FrameBufferDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_FrameBufferDesc_name_get), _SE(js_cc_pipeline_FrameBufferDesc_name_set)); + cls->defineProperty("renderPass", _SE(js_cc_pipeline_FrameBufferDesc_renderPass_get), _SE(js_cc_pipeline_FrameBufferDesc_renderPass_set)); + cls->defineProperty("colorTextures", _SE(js_cc_pipeline_FrameBufferDesc_colorTextures_get), _SE(js_cc_pipeline_FrameBufferDesc_colorTextures_set)); + cls->defineProperty("depthStencilTexture", _SE(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_get), _SE(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_FrameBufferDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_FrameBufferDesc_proto = cls->getProto(); + __jsb_cc_pipeline_FrameBufferDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderFlowType arg1 ; + std::underlying_type_t< cc::pipeline::RenderFlowType > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPassStage arg1 ; + std::underlying_type_t< cc::pipeline::RenderPassStage > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_InternalBindingDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_InternalBindingDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingDesc) + +static bool js_cc_pipeline_InternalBindingDesc_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_type_set) + +static bool js_cc_pipeline_InternalBindingDesc_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_type_get) + +static bool js_cc_pipeline_InternalBindingDesc_blockInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blockInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_blockInfo_set) + +static bool js_cc_pipeline_InternalBindingDesc_blockInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blockInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blockInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_blockInfo_get) + +static bool js_cc_pipeline_InternalBindingDesc_samplerInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_samplerInfo_set) + +static bool js_cc_pipeline_InternalBindingDesc_samplerInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_samplerInfo_get) + +static bool js_cc_pipeline_InternalBindingDesc_defaultValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defaultValue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_defaultValue_set) + +static bool js_cc_pipeline_InternalBindingDesc_defaultValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defaultValue, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defaultValue, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_defaultValue_get) + +static bool js_new_cc_pipeline_InternalBindingDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::InternalBindingDesc *result; + result = (cc::pipeline::InternalBindingDesc *)new cc::pipeline::InternalBindingDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InternalBindingDesc, __jsb_cc_pipeline_InternalBindingDesc_class, js_delete_cc_pipeline_InternalBindingDesc) + +static bool js_delete_cc_pipeline_InternalBindingDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("blockInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blockInfo), ctx); + } + + + json->getProperty("samplerInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerInfo), ctx); + } + + + json->getProperty("defaultValue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defaultValue), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_InternalBindingDesc(se::Object* obj) { + auto* cls = se::Class::create("InternalBindingDesc", obj, nullptr, _SE(js_new_cc_pipeline_InternalBindingDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_pipeline_InternalBindingDesc_type_get), _SE(js_cc_pipeline_InternalBindingDesc_type_set)); + cls->defineProperty("blockInfo", _SE(js_cc_pipeline_InternalBindingDesc_blockInfo_get), _SE(js_cc_pipeline_InternalBindingDesc_blockInfo_set)); + cls->defineProperty("samplerInfo", _SE(js_cc_pipeline_InternalBindingDesc_samplerInfo_get), _SE(js_cc_pipeline_InternalBindingDesc_samplerInfo_set)); + cls->defineProperty("defaultValue", _SE(js_cc_pipeline_InternalBindingDesc_defaultValue_get), _SE(js_cc_pipeline_InternalBindingDesc_defaultValue_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InternalBindingDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InternalBindingDesc_proto = cls->getProto(); + __jsb_cc_pipeline_InternalBindingDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_InternalBindingInst_class = nullptr; +se::Object* __jsb_cc_pipeline_InternalBindingInst_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingInst) + +static bool js_cc_pipeline_InternalBindingInst_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingInst_buffer_set) + +static bool js_cc_pipeline_InternalBindingInst_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingInst_buffer_get) + +static bool js_cc_pipeline_InternalBindingInst_sampler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampler, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingInst_sampler_set) + +static bool js_cc_pipeline_InternalBindingInst_sampler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampler, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampler, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingInst_sampler_get) + +static bool js_cc_pipeline_InternalBindingInst_texture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingInst_texture_set) + +static bool js_cc_pipeline_InternalBindingInst_texture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingInst_texture_get) + +static bool js_new_cc_pipeline_InternalBindingInst(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::InternalBindingInst *result; + result = (cc::pipeline::InternalBindingInst *)new cc::pipeline::InternalBindingInst(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InternalBindingInst, __jsb_cc_pipeline_InternalBindingInst_class, js_delete_cc_pipeline_InternalBindingInst) + +static bool js_delete_cc_pipeline_InternalBindingInst(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingInst) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingInst * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + json->getProperty("sampler", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampler), ctx); + } + + + json->getProperty("texture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texture), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_InternalBindingInst(se::Object* obj) { + auto* cls = se::Class::create("InternalBindingInst", obj, __jsb_cc_pipeline_InternalBindingDesc_proto, _SE(js_new_cc_pipeline_InternalBindingInst)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffer", _SE(js_cc_pipeline_InternalBindingInst_buffer_get), _SE(js_cc_pipeline_InternalBindingInst_buffer_set)); + cls->defineProperty("sampler", _SE(js_cc_pipeline_InternalBindingInst_sampler_get), _SE(js_cc_pipeline_InternalBindingInst_sampler_set)); + cls->defineProperty("texture", _SE(js_cc_pipeline_InternalBindingInst_texture_get), _SE(js_cc_pipeline_InternalBindingInst_texture_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InternalBindingInst)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InternalBindingInst_proto = cls->getProto(); + __jsb_cc_pipeline_InternalBindingInst_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderQueueCreateInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderQueueCreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueCreateInfo) + +static bool js_cc_pipeline_RenderQueueCreateInfo_isTransparent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isTransparent); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_set) + +static bool js_cc_pipeline_RenderQueueCreateInfo_isTransparent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isTransparent, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_get) + +static bool js_cc_pipeline_RenderQueueCreateInfo_phases_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->phases, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueCreateInfo_phases_set) + +static bool js_cc_pipeline_RenderQueueCreateInfo_phases_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->phases, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueCreateInfo_phases_get) + +static bool js_cc_pipeline_RenderQueueCreateInfo_sortFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sortFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_set) + +static bool js_cc_pipeline_RenderQueueCreateInfo_sortFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sortFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sortFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_get) + +static bool js_new_cc_pipeline_RenderQueueCreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderQueueCreateInfo *result; + result = (cc::pipeline::RenderQueueCreateInfo *)new cc::pipeline::RenderQueueCreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderQueueCreateInfo, __jsb_cc_pipeline_RenderQueueCreateInfo_class, js_delete_cc_pipeline_RenderQueueCreateInfo) + +static bool js_delete_cc_pipeline_RenderQueueCreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueCreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderQueueCreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isTransparent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isTransparent), ctx); + } + + + json->getProperty("phases", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->phases), ctx); + } + + + json->getProperty("sortFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sortFunc), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderQueueCreateInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderQueueCreateInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderQueueCreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isTransparent", _SE(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_get), _SE(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_set)); + cls->defineProperty("phases", _SE(js_cc_pipeline_RenderQueueCreateInfo_phases_get), _SE(js_cc_pipeline_RenderQueueCreateInfo_phases_set)); + cls->defineProperty("sortFunc", _SE(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_get), _SE(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderQueueCreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderQueueCreateInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderQueueCreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPriority arg1 ; + std::underlying_type_t< cc::pipeline::RenderPriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderQueueSortMode arg1 ; + std::underlying_type_t< cc::pipeline::RenderQueueSortMode > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_RenderQueueDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderQueueDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueDesc) + +static bool js_new_cc_pipeline_RenderQueueDesc__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *result; + result = (cc::pipeline::RenderQueueDesc *)new cc::pipeline::RenderQueueDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_pipeline_RenderQueueDesc__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + bool arg1 ; + cc::pipeline::RenderQueueSortMode arg2 ; + ccstd::vector< ccstd::string > *arg3 = 0 ; + ccstd::vector< ccstd::string > temp3 ; + cc::pipeline::RenderQueueDesc *result; + + ok &= sevalue_to_native(args[0], &arg1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::pipeline::RenderQueueDesc *)new cc::pipeline::RenderQueueDesc(arg1,arg2,(ccstd::vector< ccstd::string > const &)*arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_pipeline_RenderQueueDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_pipeline_RenderQueueDesc__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_pipeline_RenderQueueDesc__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of RenderQueueDesc"); + return false; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderQueueDesc, __jsb_cc_pipeline_RenderQueueDesc_class, js_delete_cc_pipeline_RenderQueueDesc) + +static bool js_cc_pipeline_RenderQueueDesc_isTransparent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isTransparent); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueDesc_isTransparent_set) + +static bool js_cc_pipeline_RenderQueueDesc_isTransparent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isTransparent, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueDesc_isTransparent_get) + +static bool js_cc_pipeline_RenderQueueDesc_sortMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sortMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueDesc_sortMode_set) + +static bool js_cc_pipeline_RenderQueueDesc_sortMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sortMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sortMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueDesc_sortMode_get) + +static bool js_cc_pipeline_RenderQueueDesc_stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueDesc_stages_set) + +static bool js_cc_pipeline_RenderQueueDesc_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueDesc_stages_get) + +static bool js_delete_cc_pipeline_RenderQueueDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueDesc) + +bool js_register_cc_pipeline_RenderQueueDesc(se::Object* obj) { + auto* cls = se::Class::create("RenderQueueDesc", obj, nullptr, _SE(js_new_cc_pipeline_RenderQueueDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isTransparent", _SE(js_cc_pipeline_RenderQueueDesc_isTransparent_get), _SE(js_cc_pipeline_RenderQueueDesc_isTransparent_set)); + cls->defineProperty("sortMode", _SE(js_cc_pipeline_RenderQueueDesc_sortMode_get), _SE(js_cc_pipeline_RenderQueueDesc_sortMode_set)); + cls->defineProperty("stages", _SE(js_cc_pipeline_RenderQueueDesc_stages_get), _SE(js_cc_pipeline_RenderQueueDesc_stages_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderQueueDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderQueueDesc_proto = cls->getProto(); + __jsb_cc_pipeline_RenderQueueDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_getPhaseID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::pipeline::getPhaseID((ccstd::string const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_getPhaseID) + +static bool js_cc_pipeline_opaqueCompareFn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = 0 ; + cc::pipeline::RenderPass *arg2 = 0 ; + cc::pipeline::RenderPass temp1 ; + cc::pipeline::RenderPass temp2 ; + bool result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)cc::pipeline::opaqueCompareFn((cc::pipeline::RenderPass const &)*arg1,(cc::pipeline::RenderPass const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_opaqueCompareFn) + +static bool js_cc_pipeline_transparentCompareFn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = 0 ; + cc::pipeline::RenderPass *arg2 = 0 ; + cc::pipeline::RenderPass temp1 ; + cc::pipeline::RenderPass temp2 ; + bool result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)cc::pipeline::transparentCompareFn((cc::pipeline::RenderPass const &)*arg1,(cc::pipeline::RenderPass const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_transparentCompareFn) + +static bool js_cc_pipeline_convertPhase(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< ccstd::string > *arg1 = 0 ; + ccstd::vector< ccstd::string > temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::pipeline::convertPhase((ccstd::vector< ccstd::string > const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_convertPhase) + +static bool js_cc_pipeline_toNumber__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::PipelineGlobalBindings arg1 ; + std::underlying_type_t< cc::pipeline::PipelineGlobalBindings > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ModelLocalBindings arg1 ; + std::underlying_type_t< cc::pipeline::ModelLocalBindings > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::SetIndex arg1 ; + std::underlying_type_t< cc::pipeline::SetIndex > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_UBOLocalBatched_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOLocalBatched_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocalBatched) + +static bool js_new_cc_pipeline_UBOLocalBatched(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOLocalBatched *result; + result = (cc::pipeline::UBOLocalBatched *)new cc::pipeline::UBOLocalBatched(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOLocalBatched, __jsb_cc_pipeline_UBOLocalBatched_class, js_delete_cc_pipeline_UBOLocalBatched) + +static bool js_delete_cc_pipeline_UBOLocalBatched(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocalBatched) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocalBatched * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOLocalBatched(se::Object* obj) { + auto* cls = se::Class::create("UBOLocalBatched", obj, nullptr, _SE(js_new_cc_pipeline_UBOLocalBatched)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOLocalBatched)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOLocalBatched_proto = cls->getProto(); + __jsb_cc_pipeline_UBOLocalBatched_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOLocal_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOLocal_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocal) + +static bool js_new_cc_pipeline_UBOLocal(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOLocal *result; + result = (cc::pipeline::UBOLocal *)new cc::pipeline::UBOLocal(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOLocal, __jsb_cc_pipeline_UBOLocal_class, js_delete_cc_pipeline_UBOLocal) + +static bool js_delete_cc_pipeline_UBOLocal(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocal) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocal * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOLocal(se::Object* obj) { + auto* cls = se::Class::create("UBOLocal", obj, nullptr, _SE(js_new_cc_pipeline_UBOLocal)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOLocal)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOLocal_proto = cls->getProto(); + __jsb_cc_pipeline_UBOLocal_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOWorldBound_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOWorldBound_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOWorldBound) + +static bool js_new_cc_pipeline_UBOWorldBound(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOWorldBound *result; + result = (cc::pipeline::UBOWorldBound *)new cc::pipeline::UBOWorldBound(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOWorldBound, __jsb_cc_pipeline_UBOWorldBound_class, js_delete_cc_pipeline_UBOWorldBound) + +static bool js_delete_cc_pipeline_UBOWorldBound(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOWorldBound) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOWorldBound * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOWorldBound(se::Object* obj) { + auto* cls = se::Class::create("UBOWorldBound", obj, nullptr, _SE(js_new_cc_pipeline_UBOWorldBound)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOWorldBound)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOWorldBound_proto = cls->getProto(); + __jsb_cc_pipeline_UBOWorldBound_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOForwardLight_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOForwardLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOForwardLight) + +static bool js_new_cc_pipeline_UBOForwardLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOForwardLight *result; + result = (cc::pipeline::UBOForwardLight *)new cc::pipeline::UBOForwardLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOForwardLight, __jsb_cc_pipeline_UBOForwardLight_class, js_delete_cc_pipeline_UBOForwardLight) + +static bool js_delete_cc_pipeline_UBOForwardLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOForwardLight) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOForwardLight * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOForwardLight(se::Object* obj) { + auto* cls = se::Class::create("UBOForwardLight", obj, nullptr, _SE(js_new_cc_pipeline_UBOForwardLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOForwardLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOForwardLight_proto = cls->getProto(); + __jsb_cc_pipeline_UBOForwardLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBODeferredLight_class = nullptr; +se::Object* __jsb_cc_pipeline_UBODeferredLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBODeferredLight) + +static bool js_new_cc_pipeline_UBODeferredLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBODeferredLight *result; + result = (cc::pipeline::UBODeferredLight *)new cc::pipeline::UBODeferredLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBODeferredLight, __jsb_cc_pipeline_UBODeferredLight_class, js_delete_cc_pipeline_UBODeferredLight) + +static bool js_delete_cc_pipeline_UBODeferredLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBODeferredLight) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBODeferredLight * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBODeferredLight(se::Object* obj) { + auto* cls = se::Class::create("UBODeferredLight", obj, nullptr, _SE(js_new_cc_pipeline_UBODeferredLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBODeferredLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBODeferredLight_proto = cls->getProto(); + __jsb_cc_pipeline_UBODeferredLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSkinningTexture_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSkinningTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningTexture) + +static bool js_new_cc_pipeline_UBOSkinningTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSkinningTexture *result; + result = (cc::pipeline::UBOSkinningTexture *)new cc::pipeline::UBOSkinningTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSkinningTexture, __jsb_cc_pipeline_UBOSkinningTexture_class, js_delete_cc_pipeline_UBOSkinningTexture) + +static bool js_delete_cc_pipeline_UBOSkinningTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningTexture) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningTexture * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSkinningTexture(se::Object* obj) { + auto* cls = se::Class::create("UBOSkinningTexture", obj, nullptr, _SE(js_new_cc_pipeline_UBOSkinningTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSkinningTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSkinningTexture_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSkinningTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSkinningAnimation_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSkinningAnimation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningAnimation) + +static bool js_new_cc_pipeline_UBOSkinningAnimation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSkinningAnimation *result; + result = (cc::pipeline::UBOSkinningAnimation *)new cc::pipeline::UBOSkinningAnimation(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSkinningAnimation, __jsb_cc_pipeline_UBOSkinningAnimation_class, js_delete_cc_pipeline_UBOSkinningAnimation) + +static bool js_delete_cc_pipeline_UBOSkinningAnimation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningAnimation) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningAnimation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSkinningAnimation(se::Object* obj) { + auto* cls = se::Class::create("UBOSkinningAnimation", obj, nullptr, _SE(js_new_cc_pipeline_UBOSkinningAnimation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSkinningAnimation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSkinningAnimation_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSkinningAnimation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSkinning_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSkinning_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinning) + +static bool js_cc_pipeline_UBOSkinning_initLayout_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint arg1 ; + + 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::pipeline::UBOSkinning::initLayout(SWIG_STD_MOVE(arg1)); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_UBOSkinning_initLayout_static) + +static bool js_new_cc_pipeline_UBOSkinning(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSkinning *result; + result = (cc::pipeline::UBOSkinning *)new cc::pipeline::UBOSkinning(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSkinning, __jsb_cc_pipeline_UBOSkinning_class, js_delete_cc_pipeline_UBOSkinning) + +static bool js_delete_cc_pipeline_UBOSkinning(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinning) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinning * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSkinning(se::Object* obj) { + auto* cls = se::Class::create("UBOSkinning", obj, nullptr, _SE(js_new_cc_pipeline_UBOSkinning)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("initLayout", _SE(js_cc_pipeline_UBOSkinning_initLayout_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSkinning)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSkinning_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSkinning_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOMorph_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOMorph_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOMorph) + +static bool js_new_cc_pipeline_UBOMorph(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOMorph *result; + result = (cc::pipeline::UBOMorph *)new cc::pipeline::UBOMorph(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOMorph, __jsb_cc_pipeline_UBOMorph_class, js_delete_cc_pipeline_UBOMorph) + +static bool js_delete_cc_pipeline_UBOMorph(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOMorph) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOMorph * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOMorph(se::Object* obj) { + auto* cls = se::Class::create("UBOMorph", obj, nullptr, _SE(js_new_cc_pipeline_UBOMorph)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOMorph)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOMorph_proto = cls->getProto(); + __jsb_cc_pipeline_UBOMorph_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOUILocal_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOUILocal_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOUILocal) + +static bool js_new_cc_pipeline_UBOUILocal(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOUILocal *result; + result = (cc::pipeline::UBOUILocal *)new cc::pipeline::UBOUILocal(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOUILocal, __jsb_cc_pipeline_UBOUILocal_class, js_delete_cc_pipeline_UBOUILocal) + +static bool js_delete_cc_pipeline_UBOUILocal(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOUILocal) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOUILocal * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOUILocal(se::Object* obj) { + auto* cls = se::Class::create("UBOUILocal", obj, nullptr, _SE(js_new_cc_pipeline_UBOUILocal)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOUILocal)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOUILocal_proto = cls->getProto(); + __jsb_cc_pipeline_UBOUILocal_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSH_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSH) + +static bool js_new_cc_pipeline_UBOSH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSH *result; + result = (cc::pipeline::UBOSH *)new cc::pipeline::UBOSH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSH, __jsb_cc_pipeline_UBOSH_class, js_delete_cc_pipeline_UBOSH) + +static bool js_delete_cc_pipeline_UBOSH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSH(se::Object* obj) { + auto* cls = se::Class::create("UBOSH", obj, nullptr, _SE(js_new_cc_pipeline_UBOSH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSH_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ForwardStagePriority arg1 ; + std::underlying_type_t< cc::pipeline::ForwardStagePriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_8(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ForwardFlowPriority arg1 ; + std::underlying_type_t< cc::pipeline::ForwardFlowPriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_9(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderFlowTag arg1 ; + std::underlying_type_t< cc::pipeline::RenderFlowTag > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_10(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::DeferredStagePriority arg1 ; + std::underlying_type_t< cc::pipeline::DeferredStagePriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_11(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::DeferredFlowPriority arg1 ; + std::underlying_type_t< cc::pipeline::DeferredFlowPriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_UBOGlobal_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOGlobal_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOGlobal) + +static bool js_new_cc_pipeline_UBOGlobal(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOGlobal *result; + result = (cc::pipeline::UBOGlobal *)new cc::pipeline::UBOGlobal(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOGlobal, __jsb_cc_pipeline_UBOGlobal_class, js_delete_cc_pipeline_UBOGlobal) + +static bool js_delete_cc_pipeline_UBOGlobal(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOGlobal) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOGlobal * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOGlobal(se::Object* obj) { + auto* cls = se::Class::create("UBOGlobal", obj, nullptr, _SE(js_new_cc_pipeline_UBOGlobal)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOGlobal)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOGlobal_proto = cls->getProto(); + __jsb_cc_pipeline_UBOGlobal_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOCamera_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOCamera_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCamera) + +static bool js_new_cc_pipeline_UBOCamera(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOCamera *result; + result = (cc::pipeline::UBOCamera *)new cc::pipeline::UBOCamera(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOCamera, __jsb_cc_pipeline_UBOCamera_class, js_delete_cc_pipeline_UBOCamera) + +static bool js_delete_cc_pipeline_UBOCamera(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCamera) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCamera * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOCamera(se::Object* obj) { + auto* cls = se::Class::create("UBOCamera", obj, nullptr, _SE(js_new_cc_pipeline_UBOCamera)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOCamera)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOCamera_proto = cls->getProto(); + __jsb_cc_pipeline_UBOCamera_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOShadow_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOShadow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOShadow) + +static bool js_new_cc_pipeline_UBOShadow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOShadow *result; + result = (cc::pipeline::UBOShadow *)new cc::pipeline::UBOShadow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOShadow, __jsb_cc_pipeline_UBOShadow_class, js_delete_cc_pipeline_UBOShadow) + +static bool js_delete_cc_pipeline_UBOShadow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOShadow) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOShadow * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOShadow(se::Object* obj) { + auto* cls = se::Class::create("UBOShadow", obj, nullptr, _SE(js_new_cc_pipeline_UBOShadow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOShadow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOShadow_proto = cls->getProto(); + __jsb_cc_pipeline_UBOShadow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOCSM_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOCSM_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCSM) + +static bool js_new_cc_pipeline_UBOCSM(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOCSM *result; + result = (cc::pipeline::UBOCSM *)new cc::pipeline::UBOCSM(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOCSM, __jsb_cc_pipeline_UBOCSM_class, js_delete_cc_pipeline_UBOCSM) + +static bool js_delete_cc_pipeline_UBOCSM(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCSM) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCSM * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOCSM(se::Object* obj) { + auto* cls = se::Class::create("UBOCSM", obj, nullptr, _SE(js_new_cc_pipeline_UBOCSM)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOCSM)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOCSM_proto = cls->getProto(); + __jsb_cc_pipeline_UBOCSM_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DescriptorSetLayoutInfos_class = nullptr; +se::Object* __jsb_cc_pipeline_DescriptorSetLayoutInfos_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DescriptorSetLayoutInfos) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_bindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_bindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindings, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindings, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_get) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_get) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_get) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storeImages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storeImages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storeImages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_get) + +static bool js_new_cc_pipeline_DescriptorSetLayoutInfos(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DescriptorSetLayoutInfos *result; + result = (cc::pipeline::DescriptorSetLayoutInfos *)new cc::pipeline::DescriptorSetLayoutInfos(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DescriptorSetLayoutInfos, __jsb_cc_pipeline_DescriptorSetLayoutInfos_class, js_delete_cc_pipeline_DescriptorSetLayoutInfos) + +static bool js_delete_cc_pipeline_DescriptorSetLayoutInfos(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DescriptorSetLayoutInfos) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DescriptorSetLayoutInfos * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindings), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("storeImages", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->storeImages), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_DescriptorSetLayoutInfos(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayoutInfos", obj, nullptr, _SE(js_new_cc_pipeline_DescriptorSetLayoutInfos)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindings", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_set)); + cls->defineProperty("blocks", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_set)); + cls->defineProperty("samplers", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_set)); + cls->defineProperty("storeImages", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DescriptorSetLayoutInfos)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DescriptorSetLayoutInfos_proto = cls->getProto(); + __jsb_cc_pipeline_DescriptorSetLayoutInfos_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_12(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::LayerList arg1 ; + std::underlying_type_t< cc::pipeline::LayerList > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_7(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_8(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_9(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_10(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_11(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_12(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_toNumber) + +static bool js_cc_pipeline_nextPow2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::nextPow2(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_nextPow2) + +static bool js_cc_pipeline_supportsR16HalfFloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsR16HalfFloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsR16HalfFloatTexture) + +static bool js_cc_pipeline_supportsRGBA16HalfFloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsRGBA16HalfFloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsRGBA16HalfFloatTexture) + +static bool js_cc_pipeline_supportsR32FloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsR32FloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsR32FloatTexture) + +static bool js_cc_pipeline_supportsRGBA32FloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsRGBA32FloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsRGBA32FloatTexture) + +se::Class* __jsb_cc_pipeline_SHADOWMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_SHADOWMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SHADOWMAP) + +static bool js_new_cc_pipeline_SHADOWMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SHADOWMAP *result; + result = (cc::pipeline::SHADOWMAP *)new cc::pipeline::SHADOWMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SHADOWMAP, __jsb_cc_pipeline_SHADOWMAP_class, js_delete_cc_pipeline_SHADOWMAP) + +static bool js_delete_cc_pipeline_SHADOWMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SHADOWMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SHADOWMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_SHADOWMAP(se::Object* obj) { + auto* cls = se::Class::create("SHADOWMAP", obj, nullptr, _SE(js_new_cc_pipeline_SHADOWMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SHADOWMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SHADOWMAP_proto = cls->getProto(); + __jsb_cc_pipeline_SHADOWMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ENVIRONMENT_class = nullptr; +se::Object* __jsb_cc_pipeline_ENVIRONMENT_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ENVIRONMENT) + +static bool js_new_cc_pipeline_ENVIRONMENT(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ENVIRONMENT *result; + result = (cc::pipeline::ENVIRONMENT *)new cc::pipeline::ENVIRONMENT(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ENVIRONMENT, __jsb_cc_pipeline_ENVIRONMENT_class, js_delete_cc_pipeline_ENVIRONMENT) + +static bool js_delete_cc_pipeline_ENVIRONMENT(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ENVIRONMENT) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::ENVIRONMENT * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_ENVIRONMENT(se::Object* obj) { + auto* cls = se::Class::create("ENVIRONMENT", obj, nullptr, _SE(js_new_cc_pipeline_ENVIRONMENT)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ENVIRONMENT)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ENVIRONMENT_proto = cls->getProto(); + __jsb_cc_pipeline_ENVIRONMENT_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_SPOTSHADOWMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_SPOTSHADOWMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SPOTSHADOWMAP) + +static bool js_new_cc_pipeline_SPOTSHADOWMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SPOTSHADOWMAP *result; + result = (cc::pipeline::SPOTSHADOWMAP *)new cc::pipeline::SPOTSHADOWMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SPOTSHADOWMAP, __jsb_cc_pipeline_SPOTSHADOWMAP_class, js_delete_cc_pipeline_SPOTSHADOWMAP) + +static bool js_delete_cc_pipeline_SPOTSHADOWMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SPOTSHADOWMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPOTSHADOWMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_SPOTSHADOWMAP(se::Object* obj) { + auto* cls = se::Class::create("SPOTSHADOWMAP", obj, nullptr, _SE(js_new_cc_pipeline_SPOTSHADOWMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SPOTSHADOWMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SPOTSHADOWMAP_proto = cls->getProto(); + __jsb_cc_pipeline_SPOTSHADOWMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DIFFUSEMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_DIFFUSEMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DIFFUSEMAP) + +static bool js_new_cc_pipeline_DIFFUSEMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DIFFUSEMAP *result; + result = (cc::pipeline::DIFFUSEMAP *)new cc::pipeline::DIFFUSEMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DIFFUSEMAP, __jsb_cc_pipeline_DIFFUSEMAP_class, js_delete_cc_pipeline_DIFFUSEMAP) + +static bool js_delete_cc_pipeline_DIFFUSEMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DIFFUSEMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DIFFUSEMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_DIFFUSEMAP(se::Object* obj) { + auto* cls = se::Class::create("DIFFUSEMAP", obj, nullptr, _SE(js_new_cc_pipeline_DIFFUSEMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DIFFUSEMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DIFFUSEMAP_proto = cls->getProto(); + __jsb_cc_pipeline_DIFFUSEMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_JOINTTEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_JOINTTEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_JOINTTEXTURE) + +static bool js_new_cc_pipeline_JOINTTEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::JOINTTEXTURE *result; + result = (cc::pipeline::JOINTTEXTURE *)new cc::pipeline::JOINTTEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_JOINTTEXTURE, __jsb_cc_pipeline_JOINTTEXTURE_class, js_delete_cc_pipeline_JOINTTEXTURE) + +static bool js_delete_cc_pipeline_JOINTTEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_JOINTTEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::JOINTTEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_JOINTTEXTURE(se::Object* obj) { + auto* cls = se::Class::create("JOINTTEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_JOINTTEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_JOINTTEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_JOINTTEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_JOINTTEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REALTIMEJOINTTEXTURE) + +static bool js_new_cc_pipeline_REALTIMEJOINTTEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REALTIMEJOINTTEXTURE *result; + result = (cc::pipeline::REALTIMEJOINTTEXTURE *)new cc::pipeline::REALTIMEJOINTTEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REALTIMEJOINTTEXTURE, __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class, js_delete_cc_pipeline_REALTIMEJOINTTEXTURE) + +static bool js_delete_cc_pipeline_REALTIMEJOINTTEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REALTIMEJOINTTEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REALTIMEJOINTTEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REALTIMEJOINTTEXTURE(se::Object* obj) { + auto* cls = se::Class::create("REALTIMEJOINTTEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_REALTIMEJOINTTEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REALTIMEJOINTTEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_POSITIONMORPH_class = nullptr; +se::Object* __jsb_cc_pipeline_POSITIONMORPH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_POSITIONMORPH) + +static bool js_new_cc_pipeline_POSITIONMORPH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::POSITIONMORPH *result; + result = (cc::pipeline::POSITIONMORPH *)new cc::pipeline::POSITIONMORPH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_POSITIONMORPH, __jsb_cc_pipeline_POSITIONMORPH_class, js_delete_cc_pipeline_POSITIONMORPH) + +static bool js_delete_cc_pipeline_POSITIONMORPH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_POSITIONMORPH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::POSITIONMORPH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_POSITIONMORPH(se::Object* obj) { + auto* cls = se::Class::create("POSITIONMORPH", obj, nullptr, _SE(js_new_cc_pipeline_POSITIONMORPH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_POSITIONMORPH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_POSITIONMORPH_proto = cls->getProto(); + __jsb_cc_pipeline_POSITIONMORPH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_NORMALMORPH_class = nullptr; +se::Object* __jsb_cc_pipeline_NORMALMORPH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_NORMALMORPH) + +static bool js_new_cc_pipeline_NORMALMORPH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::NORMALMORPH *result; + result = (cc::pipeline::NORMALMORPH *)new cc::pipeline::NORMALMORPH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_NORMALMORPH, __jsb_cc_pipeline_NORMALMORPH_class, js_delete_cc_pipeline_NORMALMORPH) + +static bool js_delete_cc_pipeline_NORMALMORPH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_NORMALMORPH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::NORMALMORPH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_NORMALMORPH(se::Object* obj) { + auto* cls = se::Class::create("NORMALMORPH", obj, nullptr, _SE(js_new_cc_pipeline_NORMALMORPH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_NORMALMORPH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_NORMALMORPH_proto = cls->getProto(); + __jsb_cc_pipeline_NORMALMORPH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_TANGENTMORPH_class = nullptr; +se::Object* __jsb_cc_pipeline_TANGENTMORPH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_TANGENTMORPH) + +static bool js_new_cc_pipeline_TANGENTMORPH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::TANGENTMORPH *result; + result = (cc::pipeline::TANGENTMORPH *)new cc::pipeline::TANGENTMORPH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_TANGENTMORPH, __jsb_cc_pipeline_TANGENTMORPH_class, js_delete_cc_pipeline_TANGENTMORPH) + +static bool js_delete_cc_pipeline_TANGENTMORPH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_TANGENTMORPH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::TANGENTMORPH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_TANGENTMORPH(se::Object* obj) { + auto* cls = se::Class::create("TANGENTMORPH", obj, nullptr, _SE(js_new_cc_pipeline_TANGENTMORPH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_TANGENTMORPH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_TANGENTMORPH_proto = cls->getProto(); + __jsb_cc_pipeline_TANGENTMORPH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_LIGHTMAPTEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_LIGHTMAPTEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_LIGHTMAPTEXTURE) + +static bool js_new_cc_pipeline_LIGHTMAPTEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::LIGHTMAPTEXTURE *result; + result = (cc::pipeline::LIGHTMAPTEXTURE *)new cc::pipeline::LIGHTMAPTEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_LIGHTMAPTEXTURE, __jsb_cc_pipeline_LIGHTMAPTEXTURE_class, js_delete_cc_pipeline_LIGHTMAPTEXTURE) + +static bool js_delete_cc_pipeline_LIGHTMAPTEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_LIGHTMAPTEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::LIGHTMAPTEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_LIGHTMAPTEXTURE(se::Object* obj) { + auto* cls = se::Class::create("LIGHTMAPTEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_LIGHTMAPTEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_LIGHTMAPTEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_LIGHTMAPTEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_LIGHTMAPTEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_SPRITETEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_SPRITETEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SPRITETEXTURE) + +static bool js_new_cc_pipeline_SPRITETEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SPRITETEXTURE *result; + result = (cc::pipeline::SPRITETEXTURE *)new cc::pipeline::SPRITETEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SPRITETEXTURE, __jsb_cc_pipeline_SPRITETEXTURE_class, js_delete_cc_pipeline_SPRITETEXTURE) + +static bool js_delete_cc_pipeline_SPRITETEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SPRITETEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPRITETEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_SPRITETEXTURE(se::Object* obj) { + auto* cls = se::Class::create("SPRITETEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_SPRITETEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SPRITETEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SPRITETEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_SPRITETEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBECUBEMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBECUBEMAP *result; + result = (cc::pipeline::REFLECTIONPROBECUBEMAP *)new cc::pipeline::REFLECTIONPROBECUBEMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBECUBEMAP, __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class, js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBECUBEMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBECUBEMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBECUBEMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBECUBEMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBEPLANARMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBEPLANARMAP *result; + result = (cc::pipeline::REFLECTIONPROBEPLANARMAP *)new cc::pipeline::REFLECTIONPROBEPLANARMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBEPLANARMAP, __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class, js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEPLANARMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBEPLANARMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBEPLANARMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBEPLANARMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBEDATAMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBEDATAMAP *result; + result = (cc::pipeline::REFLECTIONPROBEDATAMAP *)new cc::pipeline::REFLECTIONPROBEDATAMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBEDATAMAP, __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class, js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEDATAMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBEDATAMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBEDATAMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBEDATAMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP *result; + result = (cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP *)new cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP, __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class, js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBEBLENDCUBEMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_localDescriptorSetLayoutResizeMaxJoints(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + + 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::pipeline::localDescriptorSetLayoutResizeMaxJoints(SWIG_STD_MOVE(arg1)); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_localDescriptorSetLayoutResizeMaxJoints) + +se::Class* __jsb_cc_pipeline_RenderPipelineInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPipelineInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipelineInfo) + +static bool js_cc_pipeline_RenderPipelineInfo_tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipelineInfo_tag_set) + +static bool js_cc_pipeline_RenderPipelineInfo_tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tag, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipelineInfo_tag_get) + +static bool js_cc_pipeline_RenderPipelineInfo_flows_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flows, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipelineInfo_flows_set) + +static bool js_cc_pipeline_RenderPipelineInfo_flows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flows, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->flows, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipelineInfo_flows_get) + +static bool js_new_cc_pipeline_RenderPipelineInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPipelineInfo *result; + result = (cc::pipeline::RenderPipelineInfo *)new cc::pipeline::RenderPipelineInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPipelineInfo, __jsb_cc_pipeline_RenderPipelineInfo_class, js_delete_cc_pipeline_RenderPipelineInfo) + +static bool js_delete_cc_pipeline_RenderPipelineInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipelineInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPipelineInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("tag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tag), ctx); + } + + + json->getProperty("flows", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flows), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderPipelineInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderPipelineInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderPipelineInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("tag", _SE(js_cc_pipeline_RenderPipelineInfo_tag_get), _SE(js_cc_pipeline_RenderPipelineInfo_tag_set)); + cls->defineProperty("flows", _SE(js_cc_pipeline_RenderPipelineInfo_flows_get), _SE(js_cc_pipeline_RenderPipelineInfo_flows_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPipelineInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPipelineInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPipelineInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderPipeline_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipeline) + +static bool js_cc_pipeline_RenderPipeline_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderPipeline *)cc::pipeline::RenderPipeline::getInstance(); + + 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_pipeline_RenderPipeline_getInstance_static) + +static bool js_cc_pipeline_RenderPipeline_getRenderArea_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::Rect result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::pipeline::RenderPipeline::getRenderArea(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_FUNC(js_cc_pipeline_RenderPipeline_getRenderArea_static) + +static bool js_new_cc_pipeline_RenderPipeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPipeline *result; + result = (cc::pipeline::RenderPipeline *)new cc::pipeline::RenderPipeline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPipeline, __jsb_cc_pipeline_RenderPipeline_class, js_delete_cc_pipeline_RenderPipeline) + +static bool js_delete_cc_pipeline_RenderPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipeline) + +static bool js_cc_pipeline_RenderPipeline_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Swapchain *arg2 = (cc::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(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_pipeline_RenderPipeline_activate) + +static bool js_cc_pipeline_RenderPipeline_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(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_pipeline_RenderPipeline_destroy) + +static bool js_cc_pipeline_RenderPipeline_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderPipelineInfo *arg2 = 0 ; + cc::pipeline::RenderPipelineInfo 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(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)(arg1)->initialize((cc::pipeline::RenderPipelineInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_initialize) + +static bool js_cc_pipeline_RenderPipeline_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(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_pipeline_RenderPipeline_render) + +static bool js_cc_pipeline_RenderPipeline_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_onGlobalPipelineStateChanged) + +static bool js_cc_pipeline_RenderPipeline_getGlobalBindings(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::unordered_map< ccstd::string,cc::pipeline::InternalBindingInst > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::unordered_map< ccstd::string,cc::pipeline::InternalBindingInst > *) &((cc::pipeline::RenderPipeline const *)arg1)->getGlobalBindings(); + + 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_pipeline_RenderPipeline_getGlobalBindings) + +static bool js_cc_pipeline_RenderPipeline_getMacros(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::MacroRecord *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(s); + if (nullptr == arg1) return true; + result = (cc::MacroRecord *) &((cc::pipeline::RenderPipeline const *)arg1)->getMacros(); + + 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_pipeline_RenderPipeline_getMacros) + +static bool js_cc_pipeline_RenderPipeline_setValue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + int32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setValue((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_RenderPipeline_setValue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + bool arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setValue((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_RenderPipeline_setValue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setValue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_pipeline_RenderPipeline_setValue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_pipeline_RenderPipeline_setValue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_RenderPipeline_setValue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_RenderPipeline_setValue__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_setValue) + +static bool js_cc_pipeline_RenderPipeline_getCommandBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::CommandBufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::CommandBufferList *) &((cc::pipeline::RenderPipeline const *)arg1)->getCommandBuffers(); + + 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_pipeline_RenderPipeline_getCommandBuffers) + +static bool js_cc_pipeline_RenderPipeline_getQueryPools(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::QueryPoolList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueryPoolList *) &((cc::pipeline::RenderPipeline const *)arg1)->getQueryPools(); + + 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_pipeline_RenderPipeline_getQueryPools) + +static bool js_cc_pipeline_RenderPipeline_getPipelineUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::PipelineUBO *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::PipelineUBO *)((cc::pipeline::RenderPipeline const *)arg1)->getPipelineUBO(); + + 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_pipeline_RenderPipeline_getPipelineUBO) + +static bool js_cc_pipeline_RenderPipeline_getDevice(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Device *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)((cc::pipeline::RenderPipeline const *)arg1)->getDevice(); + + 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_pipeline_RenderPipeline_getDevice) + +static bool js_cc_pipeline_RenderPipeline_getRenderstageByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::pipeline::RenderStage *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(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::pipeline::RenderStage *)((cc::pipeline::RenderPipeline const *)arg1)->getRenderstageByName((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_pipeline_RenderPipeline_getRenderstageByName) + +static bool js_cc_pipeline_RenderPipeline_isOccluded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::SubModel *arg3 = (cc::scene::SubModel *) NULL ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->isOccluded((cc::scene::Camera const *)arg2,(cc::scene::SubModel const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isOccluded) + +static bool js_cc_pipeline_RenderPipeline_isOcclusionQueryEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::RenderPipeline const *)arg1)->isOcclusionQueryEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isOcclusionQueryEnabled) + +static bool js_cc_pipeline_RenderPipeline_setOcclusionQueryEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOcclusionQueryEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_setOcclusionQueryEnabled) + +static bool js_cc_pipeline_RenderPipeline_isEnvmapEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::RenderPipeline const *)arg1)->isEnvmapEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isEnvmapEnabled) + +static bool js_cc_pipeline_RenderPipeline_getViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::gfx::Viewport result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getViewport(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getViewport) + +static bool js_cc_pipeline_RenderPipeline_getScissor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::gfx::Rect result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getScissor(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getScissor) + +static bool js_cc_pipeline_RenderPipeline_genQuadVertexData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::Vec4 *arg2 = 0 ; + float *arg3 ; + cc::Vec4 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->genQuadVertexData((cc::Vec4 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_genQuadVertexData) + +static bool js_cc_pipeline_RenderPipeline_getWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::pipeline::RenderPipeline const *)arg1)->getWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getWidth) + +static bool js_cc_pipeline_RenderPipeline_getHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::pipeline::RenderPipeline const *)arg1)->getHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getHeight) + +static bool js_cc_pipeline_RenderPipeline_getClearcolor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::gfx::Color result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((cc::pipeline::RenderPipeline const *)arg1)->getClearcolor(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getClearcolor) + +static bool js_cc_pipeline_RenderPipeline_getIAByRenderArea(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Rect *arg2 = 0 ; + cc::gfx::Rect temp2 ; + cc::gfx::InputAssembler *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(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::gfx::InputAssembler *)(arg1)->getIAByRenderArea((cc::gfx::Rect 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_pipeline_RenderPipeline_getIAByRenderArea) + +static bool js_cc_pipeline_RenderPipeline_updateQuadVertexData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + cc::Vec4 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateQuadVertexData((cc::Vec4 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_updateQuadVertexData) + +static bool js_cc_pipeline_RenderPipeline_ensureEnoughSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(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)->ensureEnoughSize((ccstd::vector< cc::scene::Camera * > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_ensureEnoughSize) + +static bool js_cc_pipeline_RenderPipeline_createQuadInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + cc::gfx::Buffer **arg3 = (cc::gfx::Buffer **) NULL ; + cc::gfx::InputAssembler **arg4 = (cc::gfx::InputAssembler **) NULL ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->createQuadInputAssembler(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_createQuadInputAssembler) + +static bool js_cc_pipeline_RenderPipeline_resetRenderQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resetRenderQueue(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_resetRenderQueue) + +static bool js_cc_pipeline_RenderPipeline_isRenderQueueReset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::RenderPipeline const *)arg1)->isRenderQueueReset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isRenderQueueReset) + +static bool js_cc_pipeline_RenderPipeline_globalDSManager_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::GlobalDSManager *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::GlobalDSManager *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_globalDSManager_get) + +static bool js_cc_pipeline_RenderPipeline_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::DescriptorSet *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_descriptorSet_get) + +static bool js_cc_pipeline_RenderPipeline_descriptorSetLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_descriptorSetLayout_get) + +static bool js_cc_pipeline_RenderPipeline_constantMacros_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_constantMacros_get) + +static bool js_cc_pipeline_RenderPipeline_clusterEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_clusterEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_clusterEnabled_set) + +static bool js_cc_pipeline_RenderPipeline_clusterEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_RenderPipeline_clusterEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline_clusterEnabled_get) + +static bool js_cc_pipeline_RenderPipeline_bloomEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_bloomEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_bloomEnabled_set) + +static bool js_cc_pipeline_RenderPipeline_bloomEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_RenderPipeline_bloomEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline_bloomEnabled_get) + +static bool js_cc_pipeline_RenderPipeline_pipelineSceneData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::PipelineSceneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::PipelineSceneData *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_pipelineSceneData_get) + +static bool js_cc_pipeline_RenderPipeline_geometryRenderer_get(se::State& s) +{ +#if CC_USE_GEOMETRY_RENDERER + + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::GeometryRenderer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::GeometryRenderer *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_geometryRenderer_get) + +static bool js_cc_pipeline_RenderPipeline_profiler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_profiler_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_profiler_set) + +static bool js_cc_pipeline_RenderPipeline_profiler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_profiler_get) + +static bool js_cc_pipeline_RenderPipeline_shadingScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_shadingScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_shadingScale_set) + +static bool js_cc_pipeline_RenderPipeline_shadingScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_RenderPipeline_shadingScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline_shadingScale_get) + +static bool js_cc_pipeline_RenderPipeline__tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderPipeline__tag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline__tag_set) + +static bool js_cc_pipeline_RenderPipeline__tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderPipeline__tag_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline__tag_get) + +static bool js_cc_pipeline_RenderPipeline__flows_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderFlowList arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderPipeline__flows_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline__flows_set) + +static bool js_cc_pipeline_RenderPipeline__flows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderFlowList result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderPipeline__flows_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_pipeline_RenderPipeline__flows_get) + +bool js_register_cc_pipeline_RenderPipeline(se::Object* obj) { + auto* cls = se::Class::create("RenderPipeline", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_pipeline_RenderPipeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("globalDSManager", _SE(js_cc_pipeline_RenderPipeline_globalDSManager_get), nullptr); + cls->defineProperty("descriptorSet", _SE(js_cc_pipeline_RenderPipeline_descriptorSet_get), nullptr); + cls->defineProperty("descriptorSetLayout", _SE(js_cc_pipeline_RenderPipeline_descriptorSetLayout_get), nullptr); + cls->defineProperty("constantMacros", _SE(js_cc_pipeline_RenderPipeline_constantMacros_get), nullptr); + cls->defineProperty("clusterEnabled", _SE(js_cc_pipeline_RenderPipeline_clusterEnabled_get), _SE(js_cc_pipeline_RenderPipeline_clusterEnabled_set)); + cls->defineProperty("bloomEnabled", _SE(js_cc_pipeline_RenderPipeline_bloomEnabled_get), _SE(js_cc_pipeline_RenderPipeline_bloomEnabled_set)); + cls->defineProperty("pipelineSceneData", _SE(js_cc_pipeline_RenderPipeline_pipelineSceneData_get), nullptr); + cls->defineProperty("geometryRenderer", _SE(js_cc_pipeline_RenderPipeline_geometryRenderer_get), nullptr); + cls->defineProperty("profiler", _SE(js_cc_pipeline_RenderPipeline_profiler_get), _SE(js_cc_pipeline_RenderPipeline_profiler_set)); + cls->defineProperty("shadingScale", _SE(js_cc_pipeline_RenderPipeline_shadingScale_get), _SE(js_cc_pipeline_RenderPipeline_shadingScale_set)); + cls->defineProperty("_tag", _SE(js_cc_pipeline_RenderPipeline__tag_get), _SE(js_cc_pipeline_RenderPipeline__tag_set)); + cls->defineProperty("_flows", _SE(js_cc_pipeline_RenderPipeline__flows_get), _SE(js_cc_pipeline_RenderPipeline__flows_set)); + + cls->defineFunction("activate", _SE(js_cc_pipeline_RenderPipeline_activate)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_RenderPipeline_destroy)); + cls->defineFunction("initialize", _SE(js_cc_pipeline_RenderPipeline_initialize)); + cls->defineFunction("render", _SE(js_cc_pipeline_RenderPipeline_render)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_pipeline_RenderPipeline_onGlobalPipelineStateChanged)); + cls->defineFunction("getGlobalBindings", _SE(js_cc_pipeline_RenderPipeline_getGlobalBindings)); + cls->defineFunction("getMacros", _SE(js_cc_pipeline_RenderPipeline_getMacros)); + cls->defineFunction("setValue", _SE(js_cc_pipeline_RenderPipeline_setValue)); + cls->defineFunction("getCommandBuffers", _SE(js_cc_pipeline_RenderPipeline_getCommandBuffers)); + cls->defineFunction("getQueryPools", _SE(js_cc_pipeline_RenderPipeline_getQueryPools)); + cls->defineFunction("getPipelineUBO", _SE(js_cc_pipeline_RenderPipeline_getPipelineUBO)); + cls->defineFunction("getDevice", _SE(js_cc_pipeline_RenderPipeline_getDevice)); + cls->defineFunction("getRenderstageByName", _SE(js_cc_pipeline_RenderPipeline_getRenderstageByName)); + cls->defineFunction("isOccluded", _SE(js_cc_pipeline_RenderPipeline_isOccluded)); + cls->defineFunction("isOcclusionQueryEnabled", _SE(js_cc_pipeline_RenderPipeline_isOcclusionQueryEnabled)); + cls->defineFunction("setOcclusionQueryEnabled", _SE(js_cc_pipeline_RenderPipeline_setOcclusionQueryEnabled)); + cls->defineFunction("isEnvmapEnabled", _SE(js_cc_pipeline_RenderPipeline_isEnvmapEnabled)); + cls->defineFunction("getViewport", _SE(js_cc_pipeline_RenderPipeline_getViewport)); + cls->defineFunction("getScissor", _SE(js_cc_pipeline_RenderPipeline_getScissor)); + cls->defineFunction("genQuadVertexData", _SE(js_cc_pipeline_RenderPipeline_genQuadVertexData)); + cls->defineFunction("getWidth", _SE(js_cc_pipeline_RenderPipeline_getWidth)); + cls->defineFunction("getHeight", _SE(js_cc_pipeline_RenderPipeline_getHeight)); + cls->defineFunction("getClearcolor", _SE(js_cc_pipeline_RenderPipeline_getClearcolor)); + cls->defineFunction("getIAByRenderArea", _SE(js_cc_pipeline_RenderPipeline_getIAByRenderArea)); + cls->defineFunction("updateQuadVertexData", _SE(js_cc_pipeline_RenderPipeline_updateQuadVertexData)); + cls->defineFunction("ensureEnoughSize", _SE(js_cc_pipeline_RenderPipeline_ensureEnoughSize)); + cls->defineFunction("createQuadInputAssembler", _SE(js_cc_pipeline_RenderPipeline_createQuadInputAssembler)); + cls->defineFunction("resetRenderQueue", _SE(js_cc_pipeline_RenderPipeline_resetRenderQueue)); + cls->defineFunction("isRenderQueueReset", _SE(js_cc_pipeline_RenderPipeline_isRenderQueueReset)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_pipeline_RenderPipeline_getInstance_static)); + cls->defineStaticFunction("getRenderArea", _SE(js_cc_pipeline_RenderPipeline_getRenderArea_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPipeline_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderFlowInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderFlowInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlowInfo) + +static bool js_cc_pipeline_RenderFlowInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_name_set) + +static bool js_cc_pipeline_RenderFlowInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_name_get) + +static bool js_cc_pipeline_RenderFlowInfo_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_priority_set) + +static bool js_cc_pipeline_RenderFlowInfo_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_priority_get) + +static bool js_cc_pipeline_RenderFlowInfo_tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_tag_set) + +static bool js_cc_pipeline_RenderFlowInfo_tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tag, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_tag_get) + +static bool js_cc_pipeline_RenderFlowInfo_stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_stages_set) + +static bool js_cc_pipeline_RenderFlowInfo_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_stages_get) + +static bool js_new_cc_pipeline_RenderFlowInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderFlowInfo *result; + result = (cc::pipeline::RenderFlowInfo *)new cc::pipeline::RenderFlowInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderFlowInfo, __jsb_cc_pipeline_RenderFlowInfo_class, js_delete_cc_pipeline_RenderFlowInfo) + +static bool js_delete_cc_pipeline_RenderFlowInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlowInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderFlowInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("tag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tag), ctx); + } + + + json->getProperty("stages", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stages), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderFlowInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderFlowInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderFlowInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_RenderFlowInfo_name_get), _SE(js_cc_pipeline_RenderFlowInfo_name_set)); + cls->defineProperty("priority", _SE(js_cc_pipeline_RenderFlowInfo_priority_get), _SE(js_cc_pipeline_RenderFlowInfo_priority_set)); + cls->defineProperty("tag", _SE(js_cc_pipeline_RenderFlowInfo_tag_get), _SE(js_cc_pipeline_RenderFlowInfo_tag_set)); + cls->defineProperty("stages", _SE(js_cc_pipeline_RenderFlowInfo_stages_get), _SE(js_cc_pipeline_RenderFlowInfo_stages_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderFlowInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderFlowInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderFlowInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlow) + +static bool js_new_cc_pipeline_RenderFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderFlow *result; + result = (cc::pipeline::RenderFlow *)new cc::pipeline::RenderFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderFlow, __jsb_cc_pipeline_RenderFlow_class, js_delete_cc_pipeline_RenderFlow) + +static bool js_delete_cc_pipeline_RenderFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlow) + +static bool js_cc_pipeline_RenderFlow_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderFlowInfo *arg2 = 0 ; + cc::pipeline::RenderFlowInfo 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(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)(arg1)->initialize((cc::pipeline::RenderFlowInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_initialize) + +static bool js_cc_pipeline_RenderFlow_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderPipeline *arg2 = (cc::pipeline::RenderPipeline *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_activate) + +static bool js_cc_pipeline_RenderFlow_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_render) + +static bool js_cc_pipeline_RenderFlow_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_destroy) + +static bool js_cc_pipeline_RenderFlow_getRenderstageByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::pipeline::RenderStage *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(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::pipeline::RenderStage *)((cc::pipeline::RenderFlow const *)arg1)->getRenderstageByName((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_pipeline_RenderFlow_getRenderstageByName) + +static bool js_cc_pipeline_RenderFlow__name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_pipeline_RenderFlow__name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__name_set) + +static bool js_cc_pipeline_RenderFlow__name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_pipeline_RenderFlow__name_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_pipeline_RenderFlow__name_get) + +static bool js_cc_pipeline_RenderFlow__priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderFlow__priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__priority_set) + +static bool js_cc_pipeline_RenderFlow__priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderFlow__priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlow__priority_get) + +static bool js_cc_pipeline_RenderFlow__tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderFlow__tag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__tag_set) + +static bool js_cc_pipeline_RenderFlow__tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderFlow__tag_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlow__tag_get) + +static bool js_cc_pipeline_RenderFlow__stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderStageList arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderFlow__stages_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__stages_set) + +static bool js_cc_pipeline_RenderFlow__stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderStageList result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderFlow__stages_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_pipeline_RenderFlow__stages_get) + +bool js_register_cc_pipeline_RenderFlow(se::Object* obj) { + auto* cls = se::Class::create("RenderFlow", obj, nullptr, _SE(js_new_cc_pipeline_RenderFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_name", _SE(js_cc_pipeline_RenderFlow__name_get), _SE(js_cc_pipeline_RenderFlow__name_set)); + cls->defineProperty("_priority", _SE(js_cc_pipeline_RenderFlow__priority_get), _SE(js_cc_pipeline_RenderFlow__priority_set)); + cls->defineProperty("_tag", _SE(js_cc_pipeline_RenderFlow__tag_get), _SE(js_cc_pipeline_RenderFlow__tag_set)); + cls->defineProperty("_stages", _SE(js_cc_pipeline_RenderFlow__stages_get), _SE(js_cc_pipeline_RenderFlow__stages_set)); + + cls->defineFunction("initialize", _SE(js_cc_pipeline_RenderFlow_initialize)); + cls->defineFunction("activate", _SE(js_cc_pipeline_RenderFlow_activate)); + cls->defineFunction("render", _SE(js_cc_pipeline_RenderFlow_render)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_RenderFlow_destroy)); + cls->defineFunction("getRenderstageByName", _SE(js_cc_pipeline_RenderFlow_getRenderstageByName)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderFlow_proto = cls->getProto(); + __jsb_cc_pipeline_RenderFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderStageInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderStageInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStageInfo) + +static bool js_cc_pipeline_RenderStageInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_name_set) + +static bool js_cc_pipeline_RenderStageInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_name_get) + +static bool js_cc_pipeline_RenderStageInfo_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_priority_set) + +static bool js_cc_pipeline_RenderStageInfo_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_priority_get) + +static bool js_cc_pipeline_RenderStageInfo_tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_tag_set) + +static bool js_cc_pipeline_RenderStageInfo_tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tag, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_tag_get) + +static bool js_cc_pipeline_RenderStageInfo_renderQueues_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderQueues, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_renderQueues_set) + +static bool js_cc_pipeline_RenderStageInfo_renderQueues_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderQueues, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderQueues, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_renderQueues_get) + +static bool js_new_cc_pipeline_RenderStageInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderStageInfo *result; + result = (cc::pipeline::RenderStageInfo *)new cc::pipeline::RenderStageInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderStageInfo, __jsb_cc_pipeline_RenderStageInfo_class, js_delete_cc_pipeline_RenderStageInfo) + +static bool js_delete_cc_pipeline_RenderStageInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStageInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderStageInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("tag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tag), ctx); + } + + + json->getProperty("renderQueues", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderQueues), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderStageInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderStageInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderStageInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_RenderStageInfo_name_get), _SE(js_cc_pipeline_RenderStageInfo_name_set)); + cls->defineProperty("priority", _SE(js_cc_pipeline_RenderStageInfo_priority_get), _SE(js_cc_pipeline_RenderStageInfo_priority_set)); + cls->defineProperty("tag", _SE(js_cc_pipeline_RenderStageInfo_tag_get), _SE(js_cc_pipeline_RenderStageInfo_tag_set)); + cls->defineProperty("renderQueues", _SE(js_cc_pipeline_RenderStageInfo_renderQueues_get), _SE(js_cc_pipeline_RenderStageInfo_renderQueues_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderStageInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderStageInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderStageInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderStage_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStage) + +static bool js_new_cc_pipeline_RenderStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderStage *result; + result = (cc::pipeline::RenderStage *)new cc::pipeline::RenderStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderStage, __jsb_cc_pipeline_RenderStage_class, js_delete_cc_pipeline_RenderStage) + +static bool js_delete_cc_pipeline_RenderStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStage) + +static bool js_cc_pipeline_RenderStage_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::pipeline::RenderPipeline *arg2 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderFlow *arg3 = (cc::pipeline::RenderFlow *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_activate) + +static bool js_cc_pipeline_RenderStage_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::pipeline::RenderStageInfo *arg2 = 0 ; + cc::pipeline::RenderStageInfo 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(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)(arg1)->initialize((cc::pipeline::RenderStageInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_initialize) + +static bool js_cc_pipeline_RenderStage_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_destroy) + +static bool js_cc_pipeline_RenderStage_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_render) + +static bool js_cc_pipeline_RenderStage_getFlow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::pipeline::RenderFlow *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::RenderFlow *)((cc::pipeline::RenderStage const *)arg1)->getFlow(); + + 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_pipeline_RenderStage_getFlow) + +static bool js_cc_pipeline_RenderStage__name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_pipeline_RenderStage__name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStage__name_set) + +static bool js_cc_pipeline_RenderStage__name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_pipeline_RenderStage__name_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_pipeline_RenderStage__name_get) + +static bool js_cc_pipeline_RenderStage__priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderStage__priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStage__priority_set) + +static bool js_cc_pipeline_RenderStage__priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderStage__priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStage__priority_get) + +static bool js_cc_pipeline_RenderStage__tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderStage__tag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStage__tag_set) + +static bool js_cc_pipeline_RenderStage__tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderStage__tag_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStage__tag_get) + +bool js_register_cc_pipeline_RenderStage(se::Object* obj) { + auto* cls = se::Class::create("RenderStage", obj, nullptr, _SE(js_new_cc_pipeline_RenderStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_name", _SE(js_cc_pipeline_RenderStage__name_get), _SE(js_cc_pipeline_RenderStage__name_set)); + cls->defineProperty("_priority", _SE(js_cc_pipeline_RenderStage__priority_get), _SE(js_cc_pipeline_RenderStage__priority_set)); + cls->defineProperty("_tag", _SE(js_cc_pipeline_RenderStage__tag_get), _SE(js_cc_pipeline_RenderStage__tag_set)); + + cls->defineFunction("activate", _SE(js_cc_pipeline_RenderStage_activate)); + cls->defineFunction("initialize", _SE(js_cc_pipeline_RenderStage_initialize)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_RenderStage_destroy)); + cls->defineFunction("render", _SE(js_cc_pipeline_RenderStage_render)); + cls->defineFunction("getFlow", _SE(js_cc_pipeline_RenderStage_getFlow)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderStage_proto = cls->getProto(); + __jsb_cc_pipeline_RenderStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DebugView_class = nullptr; +se::Object* __jsb_cc_pipeline_DebugView_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DebugView) + +static bool js_new_cc_pipeline_DebugView(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DebugView *result; + result = (cc::pipeline::DebugView *)new cc::pipeline::DebugView(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DebugView, __jsb_cc_pipeline_DebugView_class, js_delete_cc_pipeline_DebugView) + +static bool js_delete_cc_pipeline_DebugView(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DebugView) + +static bool js_cc_pipeline_DebugView_isCompositeModeEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + uint32_t arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((cc::pipeline::DebugView const *)arg1)->isCompositeModeEnabled(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_isCompositeModeEnabled) + +static bool js_cc_pipeline_DebugView_enableCompositeMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + cc::pipeline::DebugViewCompositeType arg2 ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableCompositeMode(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_enableCompositeMode) + +static bool js_cc_pipeline_DebugView_enableAllCompositeMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableAllCompositeMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_enableAllCompositeMode) + +static bool js_cc_pipeline_DebugView_isEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::DebugView const *)arg1)->isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_isEnabled) + +static bool js_cc_pipeline_DebugView_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_reset) + +static bool js_cc_pipeline_DebugView_singleMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + cc::pipeline::DebugViewSingleType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_DebugView_singleMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DebugView_singleMode_set) + +static bool js_cc_pipeline_DebugView_singleMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + cc::pipeline::DebugViewSingleType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::DebugViewSingleType)cc_pipeline_DebugView_singleMode_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_pipeline_DebugView_singleMode_get) + +static bool js_cc_pipeline_DebugView_lightingWithAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_DebugView_lightingWithAlbedo_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DebugView_lightingWithAlbedo_set) + +static bool js_cc_pipeline_DebugView_lightingWithAlbedo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_DebugView_lightingWithAlbedo_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DebugView_lightingWithAlbedo_get) + +static bool js_cc_pipeline_DebugView_csmLayerColoration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_DebugView_csmLayerColoration_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DebugView_csmLayerColoration_set) + +static bool js_cc_pipeline_DebugView_csmLayerColoration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_DebugView_csmLayerColoration_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DebugView_csmLayerColoration_get) + +bool js_register_cc_pipeline_DebugView(se::Object* obj) { + auto* cls = se::Class::create("DebugView", obj, nullptr, _SE(js_new_cc_pipeline_DebugView)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("singleMode", _SE(js_cc_pipeline_DebugView_singleMode_get), _SE(js_cc_pipeline_DebugView_singleMode_set)); + cls->defineProperty("lightingWithAlbedo", _SE(js_cc_pipeline_DebugView_lightingWithAlbedo_get), _SE(js_cc_pipeline_DebugView_lightingWithAlbedo_set)); + cls->defineProperty("csmLayerColoration", _SE(js_cc_pipeline_DebugView_csmLayerColoration_get), _SE(js_cc_pipeline_DebugView_csmLayerColoration_set)); + + cls->defineFunction("isCompositeModeEnabled", _SE(js_cc_pipeline_DebugView_isCompositeModeEnabled)); + cls->defineFunction("enableCompositeMode", _SE(js_cc_pipeline_DebugView_enableCompositeMode)); + cls->defineFunction("enableAllCompositeMode", _SE(js_cc_pipeline_DebugView_enableAllCompositeMode)); + cls->defineFunction("isEnabled", _SE(js_cc_pipeline_DebugView_isEnabled)); + cls->defineFunction("reset", _SE(js_cc_pipeline_DebugView_reset)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DebugView)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DebugView_proto = cls->getProto(); + __jsb_cc_pipeline_DebugView_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ForwardPipeline_class = nullptr; +se::Object* __jsb_cc_pipeline_ForwardPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardPipeline) + +static bool js_new_cc_pipeline_ForwardPipeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ForwardPipeline *result; + result = (cc::pipeline::ForwardPipeline *)new cc::pipeline::ForwardPipeline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ForwardPipeline, __jsb_cc_pipeline_ForwardPipeline_class, js_delete_cc_pipeline_ForwardPipeline) + +static bool js_delete_cc_pipeline_ForwardPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardPipeline) + +static bool js_cc_pipeline_ForwardPipeline_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) 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(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_pipeline_ForwardPipeline_destroy) + +static bool js_cc_pipeline_ForwardPipeline_getValidLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::pipeline::LightList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::LightList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getValidLights(); + + 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_pipeline_ForwardPipeline_getValidLights) + +static bool js_cc_pipeline_ForwardPipeline_getLightBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::gfx::BufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getLightBuffers(); + + 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_pipeline_ForwardPipeline_getLightBuffers) + +static bool js_cc_pipeline_ForwardPipeline_getLightIndexOffsets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getLightIndexOffsets(); + + 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_pipeline_ForwardPipeline_getLightIndexOffsets) + +static bool js_cc_pipeline_ForwardPipeline_getLightIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getLightIndices(); + + 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_pipeline_ForwardPipeline_getLightIndices) + +bool js_register_cc_pipeline_ForwardPipeline(se::Object* obj) { + auto* cls = se::Class::create("ForwardPipeline", obj, __jsb_cc_pipeline_RenderPipeline_proto, _SE(js_new_cc_pipeline_ForwardPipeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_pipeline_ForwardPipeline_destroy)); + cls->defineFunction("getValidLights", _SE(js_cc_pipeline_ForwardPipeline_getValidLights)); + cls->defineFunction("getLightBuffers", _SE(js_cc_pipeline_ForwardPipeline_getLightBuffers)); + cls->defineFunction("getLightIndexOffsets", _SE(js_cc_pipeline_ForwardPipeline_getLightIndexOffsets)); + cls->defineFunction("getLightIndices", _SE(js_cc_pipeline_ForwardPipeline_getLightIndices)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ForwardPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ForwardPipeline_proto = cls->getProto(); + __jsb_cc_pipeline_ForwardPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ForwardFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_ForwardFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardFlow) + +static bool js_cc_pipeline_ForwardFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::ForwardFlow::getInitializeInfo(); + + 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_pipeline_ForwardFlow_getInitializeInfo_static) + +static bool js_new_cc_pipeline_ForwardFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ForwardFlow *result; + result = (cc::pipeline::ForwardFlow *)new cc::pipeline::ForwardFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ForwardFlow, __jsb_cc_pipeline_ForwardFlow_class, js_delete_cc_pipeline_ForwardFlow) + +static bool js_delete_cc_pipeline_ForwardFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardFlow) + +bool js_register_cc_pipeline_ForwardFlow(se::Object* obj) { + auto* cls = se::Class::create("ForwardFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_ForwardFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ForwardFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ForwardFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ForwardFlow_proto = cls->getProto(); + __jsb_cc_pipeline_ForwardFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ForwardStage_class = nullptr; +se::Object* __jsb_cc_pipeline_ForwardStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardStage) + +static bool js_cc_pipeline_ForwardStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::ForwardStage::getInitializeInfo(); + + 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_pipeline_ForwardStage_getInitializeInfo_static) + +static bool js_new_cc_pipeline_ForwardStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ForwardStage *result; + result = (cc::pipeline::ForwardStage *)new cc::pipeline::ForwardStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ForwardStage, __jsb_cc_pipeline_ForwardStage_class, js_delete_cc_pipeline_ForwardStage) + +static bool js_delete_cc_pipeline_ForwardStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardStage) + +bool js_register_cc_pipeline_ForwardStage(se::Object* obj) { + auto* cls = se::Class::create("ForwardStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_ForwardStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ForwardStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ForwardStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ForwardStage_proto = cls->getProto(); + __jsb_cc_pipeline_ForwardStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ShadowFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_ShadowFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowFlow) + +static bool js_new_cc_pipeline_ShadowFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ShadowFlow *result; + result = (cc::pipeline::ShadowFlow *)new cc::pipeline::ShadowFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ShadowFlow, __jsb_cc_pipeline_ShadowFlow_class, js_delete_cc_pipeline_ShadowFlow) + +static bool js_delete_cc_pipeline_ShadowFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowFlow) + +static bool js_cc_pipeline_ShadowFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::ShadowFlow::getInitializeInfo(); + + 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_pipeline_ShadowFlow_getInitializeInfo_static) + +bool js_register_cc_pipeline_ShadowFlow(se::Object* obj) { + auto* cls = se::Class::create("ShadowFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_ShadowFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ShadowFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ShadowFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ShadowFlow_proto = cls->getProto(); + __jsb_cc_pipeline_ShadowFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ShadowStage_class = nullptr; +se::Object* __jsb_cc_pipeline_ShadowStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowStage) + +static bool js_new_cc_pipeline_ShadowStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ShadowStage *result; + result = (cc::pipeline::ShadowStage *)new cc::pipeline::ShadowStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ShadowStage, __jsb_cc_pipeline_ShadowStage_class, js_delete_cc_pipeline_ShadowStage) + +static bool js_delete_cc_pipeline_ShadowStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowStage) + +static bool js_cc_pipeline_ShadowStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::ShadowStage::getInitializeInfo(); + + 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_pipeline_ShadowStage_getInitializeInfo_static) + +static bool js_cc_pipeline_ShadowStage_setFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::gfx::Framebuffer *arg2 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFramebuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowStage_setFramebuffer) + +static bool js_cc_pipeline_ShadowStage_setUsage__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + cc::scene::Light *arg3 = (cc::scene::Light *) NULL ; + cc::gfx::Framebuffer *arg4 = (cc::gfx::Framebuffer *) NULL ; + uint32_t arg5 ; + + arg1 = SE_THIS_OBJECT(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)->setUsage(arg2,(cc::scene::Light const *)arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_ShadowStage_setUsage__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + cc::scene::Light *arg3 = (cc::scene::Light *) NULL ; + cc::gfx::Framebuffer *arg4 = (cc::gfx::Framebuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->setUsage(arg2,(cc::scene::Light const *)arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_ShadowStage_setUsage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_ShadowStage_setUsage__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_ShadowStage_setUsage__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowStage_setUsage) + +static bool js_cc_pipeline_ShadowStage_clearFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->clearFramebuffer((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowStage_clearFramebuffer) + +bool js_register_cc_pipeline_ShadowStage(se::Object* obj) { + auto* cls = se::Class::create("ShadowStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_ShadowStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFramebuffer", _SE(js_cc_pipeline_ShadowStage_setFramebuffer)); + cls->defineFunction("setUsage", _SE(js_cc_pipeline_ShadowStage_setUsage)); + cls->defineFunction("clearFramebuffer", _SE(js_cc_pipeline_ShadowStage_clearFramebuffer)); + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ShadowStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ShadowStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ShadowStage_proto = cls->getProto(); + __jsb_cc_pipeline_ShadowStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ShadowTransformInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_ShadowTransformInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowTransformInfo) + +static bool js_new_cc_pipeline_ShadowTransformInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + uint32_t arg1 ; + cc::pipeline::ShadowTransformInfo *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::pipeline::ShadowTransformInfo *)new cc::pipeline::ShadowTransformInfo(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ShadowTransformInfo, __jsb_cc_pipeline_ShadowTransformInfo_class, js_delete_cc_pipeline_ShadowTransformInfo) + +static bool js_delete_cc_pipeline_ShadowTransformInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowTransformInfo) + +static bool js_cc_pipeline_ShadowTransformInfo_getLevel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::pipeline::ShadowTransformInfo const *)arg1)->getLevel(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_getLevel) + +static bool js_cc_pipeline_ShadowTransformInfo_getShadowObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::pipeline::RenderObjectList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::RenderObjectList *) &(arg1)->getShadowObjects(); + + 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_pipeline_ShadowTransformInfo_getShadowObjects) + +static bool js_cc_pipeline_ShadowTransformInfo_setShadowObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::pipeline::RenderObjectList *arg2 = 0 ; + cc::pipeline::RenderObjectList temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setShadowObjects((cc::pipeline::RenderObjectList &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setShadowObjects) + +static bool js_cc_pipeline_ShadowTransformInfo_addShadowObject(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::pipeline::RenderObject *arg2 = 0 ; + cc::pipeline::RenderObject temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addShadowObject((cc::pipeline::RenderObject &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_addShadowObject) + +static bool js_cc_pipeline_ShadowTransformInfo_clearShadowObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearShadowObjects(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_clearShadowObjects) + +static bool js_cc_pipeline_ShadowTransformInfo_getShadowCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::pipeline::ShadowTransformInfo const *)arg1)->getShadowCameraFar(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_getShadowCameraFar) + +static bool js_cc_pipeline_ShadowTransformInfo_setShadowCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowCameraFar(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setShadowCameraFar) + +static bool js_cc_pipeline_ShadowTransformInfo_getMatShadowView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getMatShadowView(); + + 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_pipeline_ShadowTransformInfo_getMatShadowView) + +static bool js_cc_pipeline_ShadowTransformInfo_setMatShadowView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMatShadowView((cc::Mat4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setMatShadowView) + +static bool js_cc_pipeline_ShadowTransformInfo_getMatShadowProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getMatShadowProj(); + + 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_pipeline_ShadowTransformInfo_getMatShadowProj) + +static bool js_cc_pipeline_ShadowTransformInfo_setMatShadowProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMatShadowProj((cc::Mat4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setMatShadowProj) + +static bool js_cc_pipeline_ShadowTransformInfo_getMatShadowViewProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getMatShadowViewProj(); + + 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_pipeline_ShadowTransformInfo_getMatShadowViewProj) + +static bool js_cc_pipeline_ShadowTransformInfo_setMatShadowViewProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMatShadowViewProj((cc::Mat4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setMatShadowViewProj) + +static bool js_cc_pipeline_ShadowTransformInfo_getValidFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *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(s); + if (nullptr == arg1) return true; + result = (geometry::Frustum *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getValidFrustum(); + + 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_pipeline_ShadowTransformInfo_getValidFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_getSplitFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *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(s); + if (nullptr == arg1) return true; + result = (geometry::Frustum *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getSplitFrustum(); + + 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_pipeline_ShadowTransformInfo_getSplitFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_getLightViewFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *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(s); + if (nullptr == arg1) return true; + result = (geometry::Frustum *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getLightViewFrustum(); + + 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_pipeline_ShadowTransformInfo_getLightViewFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_getCastLightViewBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (geometry::AABB *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getCastLightViewBoundingBox(); + + 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_pipeline_ShadowTransformInfo_getCastLightViewBoundingBox) + +static bool js_cc_pipeline_ShadowTransformInfo_createMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *arg2 = 0 ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + float arg4 ; + bool arg5 ; + geometry::Frustum temp2 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->createMatrix((geometry::Frustum const &)*arg2,(cc::scene::DirectionalLight const *)arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_createMatrix) + +static bool js_cc_pipeline_ShadowTransformInfo_copyToValidFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *arg2 = 0 ; + geometry::Frustum temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->copyToValidFrustum((geometry::Frustum const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_copyToValidFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_calculateValidFrustumOrtho(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->calculateValidFrustumOrtho(arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_calculateValidFrustumOrtho) + +static bool js_cc_pipeline_ShadowTransformInfo_calculateSplitFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->calculateSplitFrustum(arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_calculateSplitFrustum) + +bool js_register_cc_pipeline_ShadowTransformInfo(se::Object* obj) { + auto* cls = se::Class::create("ShadowTransformInfo", obj, nullptr, _SE(js_new_cc_pipeline_ShadowTransformInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getLevel", _SE(js_cc_pipeline_ShadowTransformInfo_getLevel)); + cls->defineFunction("getShadowObjects", _SE(js_cc_pipeline_ShadowTransformInfo_getShadowObjects)); + cls->defineFunction("setShadowObjects", _SE(js_cc_pipeline_ShadowTransformInfo_setShadowObjects)); + cls->defineFunction("addShadowObject", _SE(js_cc_pipeline_ShadowTransformInfo_addShadowObject)); + cls->defineFunction("clearShadowObjects", _SE(js_cc_pipeline_ShadowTransformInfo_clearShadowObjects)); + cls->defineFunction("getShadowCameraFar", _SE(js_cc_pipeline_ShadowTransformInfo_getShadowCameraFar)); + cls->defineFunction("setShadowCameraFar", _SE(js_cc_pipeline_ShadowTransformInfo_setShadowCameraFar)); + cls->defineFunction("getMatShadowView", _SE(js_cc_pipeline_ShadowTransformInfo_getMatShadowView)); + cls->defineFunction("setMatShadowView", _SE(js_cc_pipeline_ShadowTransformInfo_setMatShadowView)); + cls->defineFunction("getMatShadowProj", _SE(js_cc_pipeline_ShadowTransformInfo_getMatShadowProj)); + cls->defineFunction("setMatShadowProj", _SE(js_cc_pipeline_ShadowTransformInfo_setMatShadowProj)); + cls->defineFunction("getMatShadowViewProj", _SE(js_cc_pipeline_ShadowTransformInfo_getMatShadowViewProj)); + cls->defineFunction("setMatShadowViewProj", _SE(js_cc_pipeline_ShadowTransformInfo_setMatShadowViewProj)); + cls->defineFunction("getValidFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_getValidFrustum)); + cls->defineFunction("getSplitFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_getSplitFrustum)); + cls->defineFunction("getLightViewFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_getLightViewFrustum)); + cls->defineFunction("getCastLightViewBoundingBox", _SE(js_cc_pipeline_ShadowTransformInfo_getCastLightViewBoundingBox)); + cls->defineFunction("createMatrix", _SE(js_cc_pipeline_ShadowTransformInfo_createMatrix)); + cls->defineFunction("copyToValidFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_copyToValidFrustum)); + cls->defineFunction("calculateValidFrustumOrtho", _SE(js_cc_pipeline_ShadowTransformInfo_calculateValidFrustumOrtho)); + cls->defineFunction("calculateSplitFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_calculateSplitFrustum)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ShadowTransformInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ShadowTransformInfo_proto = cls->getProto(); + __jsb_cc_pipeline_ShadowTransformInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_CSMLayerInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_CSMLayerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayerInfo) + +static bool js_new_cc_pipeline_CSMLayerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + uint32_t arg1 ; + cc::pipeline::CSMLayerInfo *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::pipeline::CSMLayerInfo *)new cc::pipeline::CSMLayerInfo(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_CSMLayerInfo, __jsb_cc_pipeline_CSMLayerInfo_class, js_delete_cc_pipeline_CSMLayerInfo) + +static bool js_delete_cc_pipeline_CSMLayerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayerInfo) + +static bool js_cc_pipeline_CSMLayerInfo_getSplitCameraNear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::pipeline::CSMLayerInfo const *)arg1)->getSplitCameraNear(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_getSplitCameraNear) + +static bool js_cc_pipeline_CSMLayerInfo_setSplitCameraNear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSplitCameraNear(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_setSplitCameraNear) + +static bool js_cc_pipeline_CSMLayerInfo_getSplitCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::pipeline::CSMLayerInfo const *)arg1)->getSplitCameraFar(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_getSplitCameraFar) + +static bool js_cc_pipeline_CSMLayerInfo_setSplitCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSplitCameraFar(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_setSplitCameraFar) + +static bool js_cc_pipeline_CSMLayerInfo_getCSMAtlas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + cc::Vec4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &((cc::pipeline::CSMLayerInfo const *)arg1)->getCSMAtlas(); + + 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_pipeline_CSMLayerInfo_getCSMAtlas) + +bool js_register_cc_pipeline_CSMLayerInfo(se::Object* obj) { + auto* cls = se::Class::create("CSMLayerInfo", obj, __jsb_cc_pipeline_ShadowTransformInfo_proto, _SE(js_new_cc_pipeline_CSMLayerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getSplitCameraNear", _SE(js_cc_pipeline_CSMLayerInfo_getSplitCameraNear)); + cls->defineFunction("setSplitCameraNear", _SE(js_cc_pipeline_CSMLayerInfo_setSplitCameraNear)); + cls->defineFunction("getSplitCameraFar", _SE(js_cc_pipeline_CSMLayerInfo_getSplitCameraFar)); + cls->defineFunction("setSplitCameraFar", _SE(js_cc_pipeline_CSMLayerInfo_setSplitCameraFar)); + cls->defineFunction("getCSMAtlas", _SE(js_cc_pipeline_CSMLayerInfo_getCSMAtlas)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_CSMLayerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_CSMLayerInfo_proto = cls->getProto(); + __jsb_cc_pipeline_CSMLayerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_CSMLayers_class = nullptr; +se::Object* __jsb_cc_pipeline_CSMLayers_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayers) + +static bool js_new_cc_pipeline_CSMLayers(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::CSMLayers *result; + result = (cc::pipeline::CSMLayers *)new cc::pipeline::CSMLayers(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_CSMLayers, __jsb_cc_pipeline_CSMLayers_class, js_delete_cc_pipeline_CSMLayers) + +static bool js_delete_cc_pipeline_CSMLayers(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayers) + +bool js_register_cc_pipeline_CSMLayers(se::Object* obj) { + auto* cls = se::Class::create("CSMLayers", obj, nullptr, _SE(js_new_cc_pipeline_CSMLayers)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_CSMLayers)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_CSMLayers_proto = cls->getProto(); + __jsb_cc_pipeline_CSMLayers_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_GlobalDSManager_class = nullptr; +se::Object* __jsb_cc_pipeline_GlobalDSManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_GlobalDSManager) + +static bool js_new_cc_pipeline_GlobalDSManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::GlobalDSManager *result; + result = (cc::pipeline::GlobalDSManager *)new cc::pipeline::GlobalDSManager(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_GlobalDSManager, __jsb_cc_pipeline_GlobalDSManager_class, js_delete_cc_pipeline_GlobalDSManager) + +static bool js_delete_cc_pipeline_GlobalDSManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_GlobalDSManager) + +static bool js_cc_pipeline_GlobalDSManager_getLinearSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::pipeline::GlobalDSManager const *)arg1)->getLinearSampler(); + + 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_pipeline_GlobalDSManager_getLinearSampler) + +static bool js_cc_pipeline_GlobalDSManager_getPointSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::pipeline::GlobalDSManager const *)arg1)->getPointSampler(); + + 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_pipeline_GlobalDSManager_getPointSampler) + +static bool js_cc_pipeline_GlobalDSManager_getDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::DescriptorSetLayout *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)((cc::pipeline::GlobalDSManager const *)arg1)->getDescriptorSetLayout(); + + 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_pipeline_GlobalDSManager_getDescriptorSetLayout) + +static bool js_cc_pipeline_GlobalDSManager_getGlobalDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)((cc::pipeline::GlobalDSManager const *)arg1)->getGlobalDescriptorSet(); + + 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_pipeline_GlobalDSManager_getGlobalDescriptorSet) + +static bool js_cc_pipeline_GlobalDSManager_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_activate) + +static bool js_cc_pipeline_GlobalDSManager_bindBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_bindBuffer) + +static bool js_cc_pipeline_GlobalDSManager_bindTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_bindTexture) + +static bool js_cc_pipeline_GlobalDSManager_bindSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_bindSampler) + +static bool js_cc_pipeline_GlobalDSManager_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_update) + +static bool js_cc_pipeline_GlobalDSManager_getOrCreateDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::DescriptorSet *)(arg1)->getOrCreateDescriptorSet((cc::scene::Light 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_pipeline_GlobalDSManager_getOrCreateDescriptorSet) + +static bool js_cc_pipeline_GlobalDSManager_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_destroy) + +static bool js_cc_pipeline_GlobalDSManager_setDescriptorSetLayout_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::pipeline::GlobalDSManager::setDescriptorSetLayout(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_setDescriptorSetLayout_static) + +bool js_register_cc_pipeline_GlobalDSManager(se::Object* obj) { + auto* cls = se::Class::create("GlobalDSManager", obj, nullptr, _SE(js_new_cc_pipeline_GlobalDSManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getLinearSampler", _SE(js_cc_pipeline_GlobalDSManager_getLinearSampler)); + cls->defineFunction("getPointSampler", _SE(js_cc_pipeline_GlobalDSManager_getPointSampler)); + cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_pipeline_GlobalDSManager_getDescriptorSetLayout)); + cls->defineFunction("getGlobalDescriptorSet", _SE(js_cc_pipeline_GlobalDSManager_getGlobalDescriptorSet)); + cls->defineFunction("activate", _SE(js_cc_pipeline_GlobalDSManager_activate)); + cls->defineFunction("bindBuffer", _SE(js_cc_pipeline_GlobalDSManager_bindBuffer)); + cls->defineFunction("bindTexture", _SE(js_cc_pipeline_GlobalDSManager_bindTexture)); + cls->defineFunction("bindSampler", _SE(js_cc_pipeline_GlobalDSManager_bindSampler)); + cls->defineFunction("update", _SE(js_cc_pipeline_GlobalDSManager_update)); + cls->defineFunction("getOrCreateDescriptorSet", _SE(js_cc_pipeline_GlobalDSManager_getOrCreateDescriptorSet)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_GlobalDSManager_destroy)); + + + cls->defineStaticFunction("setDescriptorSetLayout", _SE(js_cc_pipeline_GlobalDSManager_setDescriptorSetLayout_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_GlobalDSManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_GlobalDSManager_proto = cls->getProto(); + __jsb_cc_pipeline_GlobalDSManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_InstancedItem_class = nullptr; +se::Object* __jsb_cc_pipeline_InstancedItem_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedItem) + +static bool js_cc_pipeline_InstancedItem_capacity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->capacity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_capacity_set) + +static bool js_cc_pipeline_InstancedItem_capacity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->capacity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_capacity_get) + +static bool js_cc_pipeline_InstancedItem_vb_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vb, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_vb_set) + +static bool js_cc_pipeline_InstancedItem_vb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vb, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vb, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_vb_get) + +static bool js_cc_pipeline_InstancedItem_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_data_set) + +static bool js_cc_pipeline_InstancedItem_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_data_get) + +static bool js_cc_pipeline_InstancedItem_ia_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ia, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_ia_set) + +static bool js_cc_pipeline_InstancedItem_ia_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ia, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ia, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_ia_get) + +static bool js_cc_pipeline_InstancedItem_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_stride_set) + +static bool js_cc_pipeline_InstancedItem_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_stride_get) + +static bool js_cc_pipeline_InstancedItem_shader_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shader, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_shader_set) + +static bool js_cc_pipeline_InstancedItem_shader_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shader, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shader, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_shader_get) + +static bool js_cc_pipeline_InstancedItem_descriptorSet_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->descriptorSet, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_descriptorSet_set) + +static bool js_cc_pipeline_InstancedItem_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->descriptorSet, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->descriptorSet, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_descriptorSet_get) + +static bool js_cc_pipeline_InstancedItem_lightingMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lightingMap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_lightingMap_set) + +static bool js_cc_pipeline_InstancedItem_lightingMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lightingMap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->lightingMap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_lightingMap_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeCubemap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbeCubemap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeCubemap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbeCubemap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->reflectionProbeCubemap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbePlanarMap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbePlanarMap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->reflectionProbePlanarMap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbeType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbeType_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbeType, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbeType_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbeBlendCubemap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbeBlendCubemap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->reflectionProbeBlendCubemap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_get) + +static bool js_cc_pipeline_InstancedItem_drawInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->drawInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_drawInfo_set) + +static bool js_cc_pipeline_InstancedItem_drawInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->drawInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->drawInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_drawInfo_get) + +static bool js_new_cc_pipeline_InstancedItem(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::InstancedItem *result; + result = (cc::pipeline::InstancedItem *)new cc::pipeline::InstancedItem(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InstancedItem, __jsb_cc_pipeline_InstancedItem_class, js_delete_cc_pipeline_InstancedItem) + +static bool js_delete_cc_pipeline_InstancedItem(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedItem) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InstancedItem * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("capacity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->capacity), ctx); + } + + + json->getProperty("vb", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vb), ctx); + } + + + json->getProperty("data", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->data), ctx); + } + + + json->getProperty("ia", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ia), ctx); + } + + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + json->getProperty("shader", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shader), ctx); + } + + + json->getProperty("descriptorSet", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->descriptorSet), ctx); + } + + + json->getProperty("lightingMap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lightingMap), ctx); + } + + + json->getProperty("reflectionProbeCubemap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbeCubemap), ctx); + } + + + json->getProperty("reflectionProbePlanarMap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbePlanarMap), ctx); + } + + + json->getProperty("reflectionProbeType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbeType), ctx); + } + + + json->getProperty("reflectionProbeBlendCubemap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbeBlendCubemap), ctx); + } + + + json->getProperty("drawInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->drawInfo), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_InstancedItem(se::Object* obj) { + auto* cls = se::Class::create("InstancedItem", obj, nullptr, _SE(js_new_cc_pipeline_InstancedItem)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("capacity", _SE(js_cc_pipeline_InstancedItem_capacity_get), _SE(js_cc_pipeline_InstancedItem_capacity_set)); + cls->defineProperty("vb", _SE(js_cc_pipeline_InstancedItem_vb_get), _SE(js_cc_pipeline_InstancedItem_vb_set)); + cls->defineProperty("data", _SE(js_cc_pipeline_InstancedItem_data_get), _SE(js_cc_pipeline_InstancedItem_data_set)); + cls->defineProperty("ia", _SE(js_cc_pipeline_InstancedItem_ia_get), _SE(js_cc_pipeline_InstancedItem_ia_set)); + cls->defineProperty("stride", _SE(js_cc_pipeline_InstancedItem_stride_get), _SE(js_cc_pipeline_InstancedItem_stride_set)); + cls->defineProperty("shader", _SE(js_cc_pipeline_InstancedItem_shader_get), _SE(js_cc_pipeline_InstancedItem_shader_set)); + cls->defineProperty("descriptorSet", _SE(js_cc_pipeline_InstancedItem_descriptorSet_get), _SE(js_cc_pipeline_InstancedItem_descriptorSet_set)); + cls->defineProperty("lightingMap", _SE(js_cc_pipeline_InstancedItem_lightingMap_get), _SE(js_cc_pipeline_InstancedItem_lightingMap_set)); + cls->defineProperty("reflectionProbeCubemap", _SE(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_set)); + cls->defineProperty("reflectionProbePlanarMap", _SE(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_set)); + cls->defineProperty("reflectionProbeType", _SE(js_cc_pipeline_InstancedItem_reflectionProbeType_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbeType_set)); + cls->defineProperty("reflectionProbeBlendCubemap", _SE(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_set)); + cls->defineProperty("drawInfo", _SE(js_cc_pipeline_InstancedItem_drawInfo_get), _SE(js_cc_pipeline_InstancedItem_drawInfo_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InstancedItem)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InstancedItem_proto = cls->getProto(); + __jsb_cc_pipeline_InstancedItem_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_InstancedBuffer_class = nullptr; +se::Object* __jsb_cc_pipeline_InstancedBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedBuffer) + +static bool js_new_cc_pipeline_InstancedBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::InstancedBuffer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::pipeline::InstancedBuffer *)new cc::pipeline::InstancedBuffer((cc::scene::Pass const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InstancedBuffer, __jsb_cc_pipeline_InstancedBuffer_class, js_delete_cc_pipeline_InstancedBuffer) + +static bool js_delete_cc_pipeline_InstancedBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedBuffer) + +static bool js_cc_pipeline_InstancedBuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_destroy) + +static bool js_cc_pipeline_InstancedBuffer_merge__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::SubModel *arg2 = (cc::scene::SubModel *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->merge(arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_InstancedBuffer_merge__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::SubModel *arg2 = (cc::scene::SubModel *) NULL ; + uint32_t arg3 ; + cc::gfx::Shader *arg4 = (cc::gfx::Shader *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->merge(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_InstancedBuffer_merge(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_pipeline_InstancedBuffer_merge__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_InstancedBuffer_merge__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_merge) + +static bool js_cc_pipeline_InstancedBuffer_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::gfx::CommandBuffer *arg2 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((cc::pipeline::InstancedBuffer const *)arg1)->uploadBuffers(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_uploadBuffers) + +static bool js_cc_pipeline_InstancedBuffer_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_clear) + +static bool js_cc_pipeline_InstancedBuffer_setDynamicOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDynamicOffset(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_setDynamicOffset) + +static bool js_cc_pipeline_InstancedBuffer_getInstances(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::pipeline::InstancedItemList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::InstancedItemList *) &((cc::pipeline::InstancedBuffer const *)arg1)->getInstances(); + + 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_pipeline_InstancedBuffer_getInstances) + +static bool js_cc_pipeline_InstancedBuffer_getSortRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::pipeline::RenderPass *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::RenderPass *) &((cc::pipeline::InstancedBuffer const *)arg1)->getSortRender(); + + 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_pipeline_InstancedBuffer_getSortRender) + +static bool js_cc_pipeline_InstancedBuffer_getPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)((cc::pipeline::InstancedBuffer const *)arg1)->getPass(); + + 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_pipeline_InstancedBuffer_getPass) + +static bool js_cc_pipeline_InstancedBuffer_setPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::Pass *arg2 = (cc::scene::Pass *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPass((cc::scene::Pass const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_setPass) + +static bool js_cc_pipeline_InstancedBuffer_hasPendingModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::InstancedBuffer const *)arg1)->hasPendingModels(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_hasPendingModels) + +static bool js_cc_pipeline_InstancedBuffer_dynamicOffsets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::pipeline::DynamicOffsetList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::DynamicOffsetList *) &((cc::pipeline::InstancedBuffer const *)arg1)->dynamicOffsets(); + + 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_pipeline_InstancedBuffer_dynamicOffsets) + +bool js_register_cc_pipeline_InstancedBuffer(se::Object* obj) { + auto* cls = se::Class::create("InstancedBuffer", obj, nullptr, _SE(js_new_cc_pipeline_InstancedBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_pipeline_InstancedBuffer_destroy)); + cls->defineFunction("merge", _SE(js_cc_pipeline_InstancedBuffer_merge)); + cls->defineFunction("uploadBuffers", _SE(js_cc_pipeline_InstancedBuffer_uploadBuffers)); + cls->defineFunction("clear", _SE(js_cc_pipeline_InstancedBuffer_clear)); + cls->defineFunction("setDynamicOffset", _SE(js_cc_pipeline_InstancedBuffer_setDynamicOffset)); + cls->defineFunction("getInstances", _SE(js_cc_pipeline_InstancedBuffer_getInstances)); + cls->defineFunction("getSortRender", _SE(js_cc_pipeline_InstancedBuffer_getSortRender)); + cls->defineFunction("getPass", _SE(js_cc_pipeline_InstancedBuffer_getPass)); + cls->defineFunction("setPass", _SE(js_cc_pipeline_InstancedBuffer_setPass)); + cls->defineFunction("hasPendingModels", _SE(js_cc_pipeline_InstancedBuffer_hasPendingModels)); + cls->defineFunction("dynamicOffsets", _SE(js_cc_pipeline_InstancedBuffer_dynamicOffsets)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InstancedBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InstancedBuffer_proto = cls->getProto(); + __jsb_cc_pipeline_InstancedBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DeferredPipeline_class = nullptr; +se::Object* __jsb_cc_pipeline_DeferredPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DeferredPipeline) + +static bool js_new_cc_pipeline_DeferredPipeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DeferredPipeline *result; + result = (cc::pipeline::DeferredPipeline *)new cc::pipeline::DeferredPipeline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DeferredPipeline, __jsb_cc_pipeline_DeferredPipeline_class, js_delete_cc_pipeline_DeferredPipeline) + +static bool js_delete_cc_pipeline_DeferredPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DeferredPipeline) + +static bool js_cc_pipeline_DeferredPipeline_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) 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(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_pipeline_DeferredPipeline_destroy) + +static bool js_cc_pipeline_DeferredPipeline_getLightsUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::pipeline::DeferredPipeline const *)arg1)->getLightsUBO(); + + 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_pipeline_DeferredPipeline_getLightsUBO) + +static bool js_cc_pipeline_DeferredPipeline_getValidLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::pipeline::LightList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::LightList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getValidLights(); + + 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_pipeline_DeferredPipeline_getValidLights) + +static bool js_cc_pipeline_DeferredPipeline_getLightBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::gfx::BufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getLightBuffers(); + + 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_pipeline_DeferredPipeline_getLightBuffers) + +static bool js_cc_pipeline_DeferredPipeline_getLightIndexOffsets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getLightIndexOffsets(); + + 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_pipeline_DeferredPipeline_getLightIndexOffsets) + +static bool js_cc_pipeline_DeferredPipeline_getLightIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getLightIndices(); + + 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_pipeline_DeferredPipeline_getLightIndices) + +bool js_register_cc_pipeline_DeferredPipeline(se::Object* obj) { + auto* cls = se::Class::create("DeferredPipeline", obj, __jsb_cc_pipeline_RenderPipeline_proto, _SE(js_new_cc_pipeline_DeferredPipeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_pipeline_DeferredPipeline_destroy)); + cls->defineFunction("getLightsUBO", _SE(js_cc_pipeline_DeferredPipeline_getLightsUBO)); + cls->defineFunction("getValidLights", _SE(js_cc_pipeline_DeferredPipeline_getValidLights)); + cls->defineFunction("getLightBuffers", _SE(js_cc_pipeline_DeferredPipeline_getLightBuffers)); + cls->defineFunction("getLightIndexOffsets", _SE(js_cc_pipeline_DeferredPipeline_getLightIndexOffsets)); + cls->defineFunction("getLightIndices", _SE(js_cc_pipeline_DeferredPipeline_getLightIndices)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DeferredPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DeferredPipeline_proto = cls->getProto(); + __jsb_cc_pipeline_DeferredPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_MainFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_MainFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_MainFlow) + +static bool js_cc_pipeline_MainFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::MainFlow::getInitializeInfo(); + + 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_pipeline_MainFlow_getInitializeInfo_static) + +static bool js_new_cc_pipeline_MainFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::MainFlow *result; + result = (cc::pipeline::MainFlow *)new cc::pipeline::MainFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_MainFlow, __jsb_cc_pipeline_MainFlow_class, js_delete_cc_pipeline_MainFlow) + +static bool js_delete_cc_pipeline_MainFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_MainFlow) + +bool js_register_cc_pipeline_MainFlow(se::Object* obj) { + auto* cls = se::Class::create("MainFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_MainFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_MainFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_MainFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_MainFlow_proto = cls->getProto(); + __jsb_cc_pipeline_MainFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_GbufferStage_class = nullptr; +se::Object* __jsb_cc_pipeline_GbufferStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_GbufferStage) + +static bool js_cc_pipeline_GbufferStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::GbufferStage::getInitializeInfo(); + + 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_pipeline_GbufferStage_getInitializeInfo_static) + +static bool js_new_cc_pipeline_GbufferStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::GbufferStage *result; + result = (cc::pipeline::GbufferStage *)new cc::pipeline::GbufferStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_GbufferStage, __jsb_cc_pipeline_GbufferStage_class, js_delete_cc_pipeline_GbufferStage) + +static bool js_delete_cc_pipeline_GbufferStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_GbufferStage) + +bool js_register_cc_pipeline_GbufferStage(se::Object* obj) { + auto* cls = se::Class::create("GbufferStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_GbufferStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_GbufferStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_GbufferStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_GbufferStage_proto = cls->getProto(); + __jsb_cc_pipeline_GbufferStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderElem_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderElem_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderElem) + +static bool js_cc_pipeline_RenderElem_renderObject_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderObject, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_renderObject_set) + +static bool js_cc_pipeline_RenderElem_renderObject_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderObject, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderObject, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_renderObject_get) + +static bool js_cc_pipeline_RenderElem_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_set_set) + +static bool js_cc_pipeline_RenderElem_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->set, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_set_get) + +static bool js_cc_pipeline_RenderElem_modelIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->modelIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_modelIndex_set) + +static bool js_cc_pipeline_RenderElem_modelIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->modelIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_modelIndex_get) + +static bool js_cc_pipeline_RenderElem_passIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_passIndex_set) + +static bool js_cc_pipeline_RenderElem_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_passIndex_get) + +static bool js_new_cc_pipeline_RenderElem(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderElem *result; + result = (cc::pipeline::RenderElem *)new cc::pipeline::RenderElem(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderElem, __jsb_cc_pipeline_RenderElem_class, js_delete_cc_pipeline_RenderElem) + +static bool js_delete_cc_pipeline_RenderElem(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderElem) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderElem * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("renderObject", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderObject), ctx); + } + + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("modelIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->modelIndex), ctx); + } + + + json->getProperty("passIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passIndex), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderElem(se::Object* obj) { + auto* cls = se::Class::create("RenderElem", obj, nullptr, _SE(js_new_cc_pipeline_RenderElem)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderObject", _SE(js_cc_pipeline_RenderElem_renderObject_get), _SE(js_cc_pipeline_RenderElem_renderObject_set)); + cls->defineProperty("set", _SE(js_cc_pipeline_RenderElem_set_get), _SE(js_cc_pipeline_RenderElem_set_set)); + cls->defineProperty("modelIndex", _SE(js_cc_pipeline_RenderElem_modelIndex_get), _SE(js_cc_pipeline_RenderElem_modelIndex_set)); + cls->defineProperty("passIndex", _SE(js_cc_pipeline_RenderElem_passIndex_get), _SE(js_cc_pipeline_RenderElem_passIndex_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderElem)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderElem_proto = cls->getProto(); + __jsb_cc_pipeline_RenderElem_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_LightingStage_class = nullptr; +se::Object* __jsb_cc_pipeline_LightingStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_LightingStage) + +static bool js_cc_pipeline_LightingStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::LightingStage::getInitializeInfo(); + + 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_pipeline_LightingStage_getInitializeInfo_static) + +static bool js_new_cc_pipeline_LightingStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::LightingStage *result; + result = (cc::pipeline::LightingStage *)new cc::pipeline::LightingStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_LightingStage, __jsb_cc_pipeline_LightingStage_class, js_delete_cc_pipeline_LightingStage) + +static bool js_delete_cc_pipeline_LightingStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_LightingStage) + +bool js_register_cc_pipeline_LightingStage(se::Object* obj) { + auto* cls = se::Class::create("LightingStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_LightingStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_LightingStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_LightingStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_LightingStage_proto = cls->getProto(); + __jsb_cc_pipeline_LightingStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_BloomStage_class = nullptr; +se::Object* __jsb_cc_pipeline_BloomStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_BloomStage) + +static bool js_new_cc_pipeline_BloomStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::BloomStage *result; + result = (cc::pipeline::BloomStage *)new cc::pipeline::BloomStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_BloomStage, __jsb_cc_pipeline_BloomStage_class, js_delete_cc_pipeline_BloomStage) + +static bool js_delete_cc_pipeline_BloomStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_BloomStage) + +static bool js_cc_pipeline_BloomStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::BloomStage::getInitializeInfo(); + + 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_pipeline_BloomStage_getInitializeInfo_static) + +static bool js_cc_pipeline_BloomStage_getPrefilterUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)(arg1)->getPrefilterUBO(); + + 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_pipeline_BloomStage_getPrefilterUBO) + +static bool js_cc_pipeline_BloomStage_getDownsampleUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::pipeline::BloomStage::SampleUBOArray *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::BloomStage::SampleUBOArray *) &(arg1)->getDownsampleUBO(); + + 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_pipeline_BloomStage_getDownsampleUBO) + +static bool js_cc_pipeline_BloomStage_getUpsampleUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::pipeline::BloomStage::SampleUBOArray *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::BloomStage::SampleUBOArray *) &(arg1)->getUpsampleUBO(); + + 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_pipeline_BloomStage_getUpsampleUBO) + +static bool js_cc_pipeline_BloomStage_getCombineUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)(arg1)->getCombineUBO(); + + 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_pipeline_BloomStage_getCombineUBO) + +static bool js_cc_pipeline_BloomStage_getSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::pipeline::BloomStage const *)arg1)->getSampler(); + + 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_pipeline_BloomStage_getSampler) + +static bool js_cc_pipeline_BloomStage_threshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_BloomStage_threshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_BloomStage_threshold_set) + +static bool js_cc_pipeline_BloomStage_threshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_BloomStage_threshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_BloomStage_threshold_get) + +static bool js_cc_pipeline_BloomStage_intensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_BloomStage_intensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_BloomStage_intensity_set) + +static bool js_cc_pipeline_BloomStage_intensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_BloomStage_intensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_BloomStage_intensity_get) + +static bool js_cc_pipeline_BloomStage_iterations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_BloomStage_iterations_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_BloomStage_iterations_set) + +static bool js_cc_pipeline_BloomStage_iterations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)cc_pipeline_BloomStage_iterations_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_BloomStage_iterations_get) + +bool js_register_cc_pipeline_BloomStage(se::Object* obj) { + auto* cls = se::Class::create("BloomStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_BloomStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("threshold", _SE(js_cc_pipeline_BloomStage_threshold_get), _SE(js_cc_pipeline_BloomStage_threshold_set)); + cls->defineProperty("intensity", _SE(js_cc_pipeline_BloomStage_intensity_get), _SE(js_cc_pipeline_BloomStage_intensity_set)); + cls->defineProperty("iterations", _SE(js_cc_pipeline_BloomStage_iterations_get), _SE(js_cc_pipeline_BloomStage_iterations_set)); + + cls->defineFunction("getPrefilterUBO", _SE(js_cc_pipeline_BloomStage_getPrefilterUBO)); + cls->defineFunction("getDownsampleUBO", _SE(js_cc_pipeline_BloomStage_getDownsampleUBO)); + cls->defineFunction("getUpsampleUBO", _SE(js_cc_pipeline_BloomStage_getUpsampleUBO)); + cls->defineFunction("getCombineUBO", _SE(js_cc_pipeline_BloomStage_getCombineUBO)); + cls->defineFunction("getSampler", _SE(js_cc_pipeline_BloomStage_getSampler)); + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_BloomStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_BloomStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_BloomStage_proto = cls->getProto(); + __jsb_cc_pipeline_BloomStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_PostProcessStage_class = nullptr; +se::Object* __jsb_cc_pipeline_PostProcessStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_PostProcessStage) + +static bool js_new_cc_pipeline_PostProcessStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::PostProcessStage *result; + result = (cc::pipeline::PostProcessStage *)new cc::pipeline::PostProcessStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_PostProcessStage, __jsb_cc_pipeline_PostProcessStage_class, js_delete_cc_pipeline_PostProcessStage) + +static bool js_delete_cc_pipeline_PostProcessStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_PostProcessStage) + +static bool js_cc_pipeline_PostProcessStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::PostProcessStage::getInitializeInfo(); + + 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_pipeline_PostProcessStage_getInitializeInfo_static) + +bool js_register_cc_pipeline_PostProcessStage(se::Object* obj) { + auto* cls = se::Class::create("PostProcessStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_PostProcessStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_PostProcessStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_PostProcessStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_PostProcessStage_proto = cls->getProto(); + __jsb_cc_pipeline_PostProcessStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_PipelineSceneData_class = nullptr; +se::Object* __jsb_cc_pipeline_PipelineSceneData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_PipelineSceneData) + +static bool js_new_cc_pipeline_PipelineSceneData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::PipelineSceneData *result; + result = (cc::pipeline::PipelineSceneData *)new cc::pipeline::PipelineSceneData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_PipelineSceneData, __jsb_cc_pipeline_PipelineSceneData_class, js_delete_cc_pipeline_PipelineSceneData) + +static bool js_delete_cc_pipeline_PipelineSceneData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_PipelineSceneData) + +static bool js_cc_pipeline_PipelineSceneData_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_activate) + +static bool js_cc_pipeline_PipelineSceneData_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_destroy) + +static bool js_cc_pipeline_PipelineSceneData_updatePipelineSceneData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updatePipelineSceneData(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_updatePipelineSceneData) + +static bool js_cc_pipeline_PipelineSceneData_setShadowFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setShadowFramebuffer((cc::scene::Light const *)arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_setShadowFramebuffer) + +static bool js_cc_pipeline_PipelineSceneData_getOctree(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Octree *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Octree *)((cc::pipeline::PipelineSceneData const *)arg1)->getOctree(); + + 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_pipeline_PipelineSceneData_getOctree) + +static bool js_cc_pipeline_PipelineSceneData_getOcclusionQueryInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::InputAssembler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssembler *)((cc::pipeline::PipelineSceneData const *)arg1)->getOcclusionQueryInputAssembler(); + + 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_pipeline_PipelineSceneData_getOcclusionQueryInputAssembler) + +static bool js_cc_pipeline_PipelineSceneData_getOcclusionQueryPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)((cc::pipeline::PipelineSceneData const *)arg1)->getOcclusionQueryPass(); + + 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_pipeline_PipelineSceneData_getOcclusionQueryPass) + +static bool js_cc_pipeline_PipelineSceneData_getOcclusionQueryShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::Shader *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)((cc::pipeline::PipelineSceneData const *)arg1)->getOcclusionQueryShader(); + + 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_pipeline_PipelineSceneData_getOcclusionQueryShader) + +static bool js_cc_pipeline_PipelineSceneData_getGeometryRendererMaterials(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::Material > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::Material > > *) &((cc::pipeline::PipelineSceneData const *)arg1)->getGeometryRendererMaterials(); + + 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_pipeline_PipelineSceneData_getGeometryRendererMaterials) + +static bool js_cc_pipeline_PipelineSceneData_getGeometryRendererPasses(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::scene::Pass * > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::scene::Pass * > *) &((cc::pipeline::PipelineSceneData const *)arg1)->getGeometryRendererPasses(); + + 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_pipeline_PipelineSceneData_getGeometryRendererPasses) + +static bool js_cc_pipeline_PipelineSceneData_getGeometryRendererShaders(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::gfx::Shader * > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gfx::Shader * > *) &((cc::pipeline::PipelineSceneData const *)arg1)->getGeometryRendererShaders(); + + 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_pipeline_PipelineSceneData_getGeometryRendererShaders) + +static bool js_cc_pipeline_PipelineSceneData_getDebugRendererPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)((cc::pipeline::PipelineSceneData const *)arg1)->getDebugRendererPass(); + + 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_pipeline_PipelineSceneData_getDebugRendererPass) + +static bool js_cc_pipeline_PipelineSceneData_getDebugRendererShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::Shader *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)((cc::pipeline::PipelineSceneData const *)arg1)->getDebugRendererShader(); + + 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_pipeline_PipelineSceneData_getDebugRendererShader) + +static bool js_cc_pipeline_PipelineSceneData_addRenderObject(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::pipeline::RenderObject *arg2 = 0 ; + cc::pipeline::RenderObject temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addRenderObject((cc::pipeline::RenderObject &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_addRenderObject) + +static bool js_cc_pipeline_PipelineSceneData_clearRenderObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearRenderObjects(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_clearRenderObjects) + +static bool js_cc_pipeline_PipelineSceneData_addValidPunctualLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addValidPunctualLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_addValidPunctualLight) + +static bool js_cc_pipeline_PipelineSceneData_clearValidPunctualLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearValidPunctualLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_clearValidPunctualLights) + +static bool js_cc_pipeline_PipelineSceneData_setCSMSupported(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCSMSupported(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_setCSMSupported) + +static bool js_cc_pipeline_PipelineSceneData_isHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_isHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_isHDR_set) + +static bool js_cc_pipeline_PipelineSceneData_isHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_PipelineSceneData_isHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_PipelineSceneData_isHDR_get) + +static bool js_cc_pipeline_PipelineSceneData_shadingScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_shadingScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_shadingScale_set) + +static bool js_cc_pipeline_PipelineSceneData_shadingScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_PipelineSceneData_shadingScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_PipelineSceneData_shadingScale_get) + +static bool js_cc_pipeline_PipelineSceneData_fog_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Fog *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Fog *)cc_pipeline_PipelineSceneData_fog_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_pipeline_PipelineSceneData_fog_get) + +static bool js_cc_pipeline_PipelineSceneData_ambient_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Ambient *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Ambient *)cc_pipeline_PipelineSceneData_ambient_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_pipeline_PipelineSceneData_ambient_get) + +static bool js_cc_pipeline_PipelineSceneData_skybox_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Skybox *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Skybox *)cc_pipeline_PipelineSceneData_skybox_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_pipeline_PipelineSceneData_skybox_get) + +static bool js_cc_pipeline_PipelineSceneData_shadows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Shadows *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Shadows *)cc_pipeline_PipelineSceneData_shadows_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_pipeline_PipelineSceneData_shadows_get) + +static bool js_cc_pipeline_PipelineSceneData_skin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Skin *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Skin *)cc_pipeline_PipelineSceneData_skin_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_pipeline_PipelineSceneData_skin_get) + +static bool js_cc_pipeline_PipelineSceneData_postSettings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::PostSettings *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::PostSettings *)cc_pipeline_PipelineSceneData_postSettings_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_pipeline_PipelineSceneData_postSettings_get) + +static bool js_cc_pipeline_PipelineSceneData_lightProbes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gi::LightProbes *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbes *)cc_pipeline_PipelineSceneData_lightProbes_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_pipeline_PipelineSceneData_lightProbes_get) + +static bool js_cc_pipeline_PipelineSceneData_validPunctualLights_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::scene::Light const * > arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_PipelineSceneData_validPunctualLights_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_validPunctualLights_set) + +static bool js_cc_pipeline_PipelineSceneData_validPunctualLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::scene::Light const * > result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_PipelineSceneData_validPunctualLights_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_pipeline_PipelineSceneData_validPunctualLights_get) + +static bool js_cc_pipeline_PipelineSceneData_csmSupported_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_PipelineSceneData_csmSupported_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_PipelineSceneData_csmSupported_get) + +static bool js_cc_pipeline_PipelineSceneData_standardSkinModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_standardSkinModel_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_standardSkinModel_set) + +static bool js_cc_pipeline_PipelineSceneData_standardSkinModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_pipeline_PipelineSceneData_standardSkinModel_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_pipeline_PipelineSceneData_standardSkinModel_get) + +static bool js_cc_pipeline_PipelineSceneData_skinMaterialModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_skinMaterialModel_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_skinMaterialModel_set) + +static bool js_cc_pipeline_PipelineSceneData_skinMaterialModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_pipeline_PipelineSceneData_skinMaterialModel_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_pipeline_PipelineSceneData_skinMaterialModel_get) + +bool js_register_cc_pipeline_PipelineSceneData(se::Object* obj) { + auto* cls = se::Class::create("PipelineSceneData", obj, nullptr, _SE(js_new_cc_pipeline_PipelineSceneData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isHDR", _SE(js_cc_pipeline_PipelineSceneData_isHDR_get), _SE(js_cc_pipeline_PipelineSceneData_isHDR_set)); + cls->defineProperty("shadingScale", _SE(js_cc_pipeline_PipelineSceneData_shadingScale_get), _SE(js_cc_pipeline_PipelineSceneData_shadingScale_set)); + cls->defineProperty("fog", _SE(js_cc_pipeline_PipelineSceneData_fog_get), nullptr); + cls->defineProperty("ambient", _SE(js_cc_pipeline_PipelineSceneData_ambient_get), nullptr); + cls->defineProperty("skybox", _SE(js_cc_pipeline_PipelineSceneData_skybox_get), nullptr); + cls->defineProperty("shadows", _SE(js_cc_pipeline_PipelineSceneData_shadows_get), nullptr); + cls->defineProperty("skin", _SE(js_cc_pipeline_PipelineSceneData_skin_get), nullptr); + cls->defineProperty("postSettings", _SE(js_cc_pipeline_PipelineSceneData_postSettings_get), nullptr); + cls->defineProperty("lightProbes", _SE(js_cc_pipeline_PipelineSceneData_lightProbes_get), nullptr); + cls->defineProperty("validPunctualLights", _SE(js_cc_pipeline_PipelineSceneData_validPunctualLights_get), _SE(js_cc_pipeline_PipelineSceneData_validPunctualLights_set)); + cls->defineProperty("csmSupported", _SE(js_cc_pipeline_PipelineSceneData_csmSupported_get), nullptr); + cls->defineProperty("standardSkinModel", _SE(js_cc_pipeline_PipelineSceneData_standardSkinModel_get), _SE(js_cc_pipeline_PipelineSceneData_standardSkinModel_set)); + cls->defineProperty("skinMaterialModel", _SE(js_cc_pipeline_PipelineSceneData_skinMaterialModel_get), _SE(js_cc_pipeline_PipelineSceneData_skinMaterialModel_set)); + + cls->defineFunction("activate", _SE(js_cc_pipeline_PipelineSceneData_activate)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_PipelineSceneData_destroy)); + cls->defineFunction("updatePipelineSceneData", _SE(js_cc_pipeline_PipelineSceneData_updatePipelineSceneData)); + cls->defineFunction("setShadowFramebuffer", _SE(js_cc_pipeline_PipelineSceneData_setShadowFramebuffer)); + cls->defineFunction("getOctree", _SE(js_cc_pipeline_PipelineSceneData_getOctree)); + cls->defineFunction("getOcclusionQueryInputAssembler", _SE(js_cc_pipeline_PipelineSceneData_getOcclusionQueryInputAssembler)); + cls->defineFunction("getOcclusionQueryPass", _SE(js_cc_pipeline_PipelineSceneData_getOcclusionQueryPass)); + cls->defineFunction("getOcclusionQueryShader", _SE(js_cc_pipeline_PipelineSceneData_getOcclusionQueryShader)); + cls->defineFunction("getGeometryRendererMaterials", _SE(js_cc_pipeline_PipelineSceneData_getGeometryRendererMaterials)); + cls->defineFunction("getGeometryRendererPasses", _SE(js_cc_pipeline_PipelineSceneData_getGeometryRendererPasses)); + cls->defineFunction("getGeometryRendererShaders", _SE(js_cc_pipeline_PipelineSceneData_getGeometryRendererShaders)); + cls->defineFunction("getDebugRendererPass", _SE(js_cc_pipeline_PipelineSceneData_getDebugRendererPass)); + cls->defineFunction("getDebugRendererShader", _SE(js_cc_pipeline_PipelineSceneData_getDebugRendererShader)); + cls->defineFunction("addRenderObject", _SE(js_cc_pipeline_PipelineSceneData_addRenderObject)); + cls->defineFunction("clearRenderObjects", _SE(js_cc_pipeline_PipelineSceneData_clearRenderObjects)); + cls->defineFunction("addValidPunctualLight", _SE(js_cc_pipeline_PipelineSceneData_addValidPunctualLight)); + cls->defineFunction("clearValidPunctualLights", _SE(js_cc_pipeline_PipelineSceneData_clearValidPunctualLights)); + cls->defineFunction("setCSMSupported", _SE(js_cc_pipeline_PipelineSceneData_setCSMSupported)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_PipelineSceneData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_PipelineSceneData_proto = cls->getProto(); + __jsb_cc_pipeline_PipelineSceneData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#if CC_USE_GEOMETRY_RENDERER + +se::Class* __jsb_cc_pipeline_GeometryRenderer_class = nullptr; +se::Object* __jsb_cc_pipeline_GeometryRenderer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_GeometryRenderer) + +static bool js_new_cc_pipeline_GeometryRenderer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::GeometryRenderer *result; + result = (cc::pipeline::GeometryRenderer *)new cc::pipeline::GeometryRenderer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_GeometryRenderer, __jsb_cc_pipeline_GeometryRenderer_class, js_delete_cc_pipeline_GeometryRenderer) + +static bool js_delete_cc_pipeline_GeometryRenderer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_GeometryRenderer) + +static bool js_cc_pipeline_GeometryRenderer_empty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::GeometryRenderer const *)arg1)->empty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_empty) + +static bool js_cc_pipeline_GeometryRenderer_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_update) + +static bool js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDashedLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDashedLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDashedLine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addDashedLine) + +static bool js_cc_pipeline_GeometryRenderer_addLine__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addLine__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addLine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addLine__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addLine__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addLine) + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addTriangle) + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addQuad) + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + cc::Mat4 *arg8 = 0 ; + cc::geometry::AABB temp2 ; + cc::Mat4 temp8 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5,arg6,arg7,(cc::Mat4 const &)*arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addBoundingBox) + +static bool js_cc_pipeline_GeometryRenderer_addCross__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCross((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCross__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCross((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCross(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCross__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addCross__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCross) + +static bool js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addFrustum((cc::geometry::Frustum const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::gfx::Color arg3 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addFrustum((cc::geometry::Frustum const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addFrustum) + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Mat4 *arg12 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp12 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &temp12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg12 = &temp12; + + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(cc::Mat4 const &)*arg12); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 11) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCapsule) + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Mat4 *arg11 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp11 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &temp11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg11 = &temp11; + + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(cc::Mat4 const &)*arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCylinder) + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Mat4 *arg11 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp11 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &temp11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg11 = &temp11; + + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(cc::Mat4 const &)*arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCone) + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Mat4 *arg8 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp8 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,(cc::Mat4 const &)*arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCircle) + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addArc) + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addPolygon) + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addDisc) + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Mat4 *arg12 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp12 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &temp12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg12 = &temp12; + + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(cc::Mat4 const &)*arg12); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 11) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addSector) + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Mat4 *arg11 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp11 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &temp11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg11 = &temp11; + + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(cc::Mat4 const &)*arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addSphere) + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Mat4 *arg12 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp12 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &temp12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg12 = &temp12; + + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(cc::Mat4 const &)*arg12); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 11) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addTorus) + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Mat4 *arg9 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp9 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &temp9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg9 = &temp9; + + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(cc::Mat4 const &)*arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addOctahedron) + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addBezier) + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Mat4 *arg9 = 0 ; + cc::geometry::Spline temp2 ; + cc::Mat4 temp9 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &temp9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg9 = &temp9; + + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(cc::Mat4 const &)*arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSpline((cc::geometry::Spline const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addSpline) + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + cc::Mat4 *arg7 = 0 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + cc::Mat4 temp7 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4,arg5,arg6,(cc::Mat4 const &)*arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addMesh) + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + cc::Mat4 *arg8 = 0 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + cc::Mat4 temp8 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5,arg6,arg7,(cc::Mat4 const &)*arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addIndexedMesh) + +bool js_register_cc_pipeline_GeometryRenderer(se::Object* obj) { + auto* cls = se::Class::create("GeometryRenderer", obj, nullptr, _SE(js_new_cc_pipeline_GeometryRenderer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("empty", _SE(js_cc_pipeline_GeometryRenderer_empty)); + cls->defineFunction("update", _SE(js_cc_pipeline_GeometryRenderer_update)); + cls->defineFunction("addDashedLine", _SE(js_cc_pipeline_GeometryRenderer_addDashedLine)); + cls->defineFunction("addLine", _SE(js_cc_pipeline_GeometryRenderer_addLine)); + cls->defineFunction("addTriangle", _SE(js_cc_pipeline_GeometryRenderer_addTriangle)); + cls->defineFunction("addQuad", _SE(js_cc_pipeline_GeometryRenderer_addQuad)); + cls->defineFunction("addBoundingBox", _SE(js_cc_pipeline_GeometryRenderer_addBoundingBox)); + cls->defineFunction("addCross", _SE(js_cc_pipeline_GeometryRenderer_addCross)); + cls->defineFunction("addFrustum", _SE(js_cc_pipeline_GeometryRenderer_addFrustum)); + cls->defineFunction("addCapsule", _SE(js_cc_pipeline_GeometryRenderer_addCapsule)); + cls->defineFunction("addCylinder", _SE(js_cc_pipeline_GeometryRenderer_addCylinder)); + cls->defineFunction("addCone", _SE(js_cc_pipeline_GeometryRenderer_addCone)); + cls->defineFunction("addCircle", _SE(js_cc_pipeline_GeometryRenderer_addCircle)); + cls->defineFunction("addArc", _SE(js_cc_pipeline_GeometryRenderer_addArc)); + cls->defineFunction("addPolygon", _SE(js_cc_pipeline_GeometryRenderer_addPolygon)); + cls->defineFunction("addDisc", _SE(js_cc_pipeline_GeometryRenderer_addDisc)); + cls->defineFunction("addSector", _SE(js_cc_pipeline_GeometryRenderer_addSector)); + cls->defineFunction("addSphere", _SE(js_cc_pipeline_GeometryRenderer_addSphere)); + cls->defineFunction("addTorus", _SE(js_cc_pipeline_GeometryRenderer_addTorus)); + cls->defineFunction("addOctahedron", _SE(js_cc_pipeline_GeometryRenderer_addOctahedron)); + cls->defineFunction("addBezier", _SE(js_cc_pipeline_GeometryRenderer_addBezier)); + cls->defineFunction("addSpline", _SE(js_cc_pipeline_GeometryRenderer_addSpline)); + cls->defineFunction("addMesh", _SE(js_cc_pipeline_GeometryRenderer_addMesh)); + cls->defineFunction("addIndexedMesh", _SE(js_cc_pipeline_GeometryRenderer_addIndexedMesh)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_GeometryRenderer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_GeometryRenderer_proto = cls->getProto(); + __jsb_cc_pipeline_GeometryRenderer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#endif // CC_USE_GEOMETRY_RENDERER + +se::Class* __jsb_cc_pipeline_ReflectionProbeFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_ReflectionProbeFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeFlow) + +static bool js_new_cc_pipeline_ReflectionProbeFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ReflectionProbeFlow *result; + result = (cc::pipeline::ReflectionProbeFlow *)new cc::pipeline::ReflectionProbeFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ReflectionProbeFlow, __jsb_cc_pipeline_ReflectionProbeFlow_class, js_delete_cc_pipeline_ReflectionProbeFlow) + +static bool js_delete_cc_pipeline_ReflectionProbeFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeFlow) + +static bool js_cc_pipeline_ReflectionProbeFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::ReflectionProbeFlow::getInitializeInfo(); + + 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_pipeline_ReflectionProbeFlow_getInitializeInfo_static) + +bool js_register_cc_pipeline_ReflectionProbeFlow(se::Object* obj) { + auto* cls = se::Class::create("ReflectionProbeFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_ReflectionProbeFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ReflectionProbeFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ReflectionProbeFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ReflectionProbeFlow_proto = cls->getProto(); + __jsb_cc_pipeline_ReflectionProbeFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ReflectionProbeStage_class = nullptr; +se::Object* __jsb_cc_pipeline_ReflectionProbeStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeStage) + +static bool js_new_cc_pipeline_ReflectionProbeStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ReflectionProbeStage *result; + result = (cc::pipeline::ReflectionProbeStage *)new cc::pipeline::ReflectionProbeStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ReflectionProbeStage, __jsb_cc_pipeline_ReflectionProbeStage_class, js_delete_cc_pipeline_ReflectionProbeStage) + +static bool js_delete_cc_pipeline_ReflectionProbeStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeStage) + +static bool js_cc_pipeline_ReflectionProbeStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::ReflectionProbeStage::getInitializeInfo(); + + 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_pipeline_ReflectionProbeStage_getInitializeInfo_static) + +static bool js_cc_pipeline_ReflectionProbeStage_setFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ReflectionProbeStage *arg1 = (cc::pipeline::ReflectionProbeStage *) NULL ; + cc::gfx::Framebuffer *arg2 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFramebuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ReflectionProbeStage_setFramebuffer) + +static bool js_cc_pipeline_ReflectionProbeStage_setUsage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ReflectionProbeStage *arg1 = (cc::pipeline::ReflectionProbeStage *) NULL ; + cc::gfx::Framebuffer *arg2 = (cc::gfx::Framebuffer *) NULL ; + cc::scene::ReflectionProbe *arg3 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setUsage(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ReflectionProbeStage_setUsage) + +bool js_register_cc_pipeline_ReflectionProbeStage(se::Object* obj) { + auto* cls = se::Class::create("ReflectionProbeStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_ReflectionProbeStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFramebuffer", _SE(js_cc_pipeline_ReflectionProbeStage_setFramebuffer)); + cls->defineFunction("setUsage", _SE(js_cc_pipeline_ReflectionProbeStage_setUsage)); + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ReflectionProbeStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ReflectionProbeStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ReflectionProbeStage_proto = cls->getProto(); + __jsb_cc_pipeline_ReflectionProbeStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_pipeline(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("nr", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("nr", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_pipeline_SkinningJointCapacity(ns); + js_register_cc_pipeline_RenderObject(ns); + js_register_cc_pipeline_RenderTargetInfo(ns); + js_register_cc_pipeline_RenderPass(ns); + js_register_cc_pipeline_RenderPassDesc(ns); + js_register_cc_pipeline_RenderTextureDesc(ns); + js_register_cc_pipeline_FrameBufferDesc(ns); + js_register_cc_pipeline_InternalBindingDesc(ns); + js_register_cc_pipeline_InternalBindingInst(ns); + js_register_cc_pipeline_RenderQueueCreateInfo(ns); + js_register_cc_pipeline_RenderQueueDesc(ns); + js_register_cc_pipeline_UBOLocalBatched(ns); + js_register_cc_pipeline_UBOLocal(ns); + js_register_cc_pipeline_UBOWorldBound(ns); + js_register_cc_pipeline_UBOForwardLight(ns); + js_register_cc_pipeline_UBODeferredLight(ns); + js_register_cc_pipeline_UBOSkinningTexture(ns); + js_register_cc_pipeline_UBOSkinningAnimation(ns); + js_register_cc_pipeline_UBOSkinning(ns); + js_register_cc_pipeline_UBOMorph(ns); + js_register_cc_pipeline_UBOUILocal(ns); + js_register_cc_pipeline_UBOSH(ns); + js_register_cc_pipeline_UBOGlobal(ns); + js_register_cc_pipeline_UBOCamera(ns); + js_register_cc_pipeline_UBOShadow(ns); + js_register_cc_pipeline_UBOCSM(ns); + js_register_cc_pipeline_DescriptorSetLayoutInfos(ns); + js_register_cc_pipeline_SHADOWMAP(ns); + js_register_cc_pipeline_ENVIRONMENT(ns); + js_register_cc_pipeline_SPOTSHADOWMAP(ns); + js_register_cc_pipeline_DIFFUSEMAP(ns); + js_register_cc_pipeline_JOINTTEXTURE(ns); + js_register_cc_pipeline_REALTIMEJOINTTEXTURE(ns); + js_register_cc_pipeline_POSITIONMORPH(ns); + js_register_cc_pipeline_NORMALMORPH(ns); + js_register_cc_pipeline_TANGENTMORPH(ns); + js_register_cc_pipeline_LIGHTMAPTEXTURE(ns); + js_register_cc_pipeline_SPRITETEXTURE(ns); + js_register_cc_pipeline_REFLECTIONPROBECUBEMAP(ns); + js_register_cc_pipeline_REFLECTIONPROBEPLANARMAP(ns); + js_register_cc_pipeline_REFLECTIONPROBEDATAMAP(ns); + js_register_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(ns); + js_register_cc_pipeline_RenderPipelineInfo(ns); + js_register_cc_pipeline_RenderPipeline(ns); + js_register_cc_pipeline_RenderFlowInfo(ns); + js_register_cc_pipeline_RenderFlow(ns); + js_register_cc_pipeline_RenderStageInfo(ns); + js_register_cc_pipeline_RenderStage(ns); + js_register_cc_pipeline_DebugView(ns); + js_register_cc_pipeline_ForwardPipeline(ns); + js_register_cc_pipeline_ForwardFlow(ns); + js_register_cc_pipeline_ForwardStage(ns); + js_register_cc_pipeline_ShadowFlow(ns); + js_register_cc_pipeline_ShadowStage(ns); + js_register_cc_pipeline_ShadowTransformInfo(ns); + js_register_cc_pipeline_CSMLayerInfo(ns); + js_register_cc_pipeline_CSMLayers(ns); + js_register_cc_pipeline_GlobalDSManager(ns); + js_register_cc_pipeline_InstancedItem(ns); + js_register_cc_pipeline_InstancedBuffer(ns); + js_register_cc_pipeline_DeferredPipeline(ns); + js_register_cc_pipeline_MainFlow(ns); + js_register_cc_pipeline_GbufferStage(ns); + js_register_cc_pipeline_RenderElem(ns); + js_register_cc_pipeline_LightingStage(ns); + js_register_cc_pipeline_BloomStage(ns); + js_register_cc_pipeline_PostProcessStage(ns); + js_register_cc_pipeline_PipelineSceneData(ns); +#if CC_USE_GEOMETRY_RENDERER + js_register_cc_pipeline_GeometryRenderer(ns); +#endif // CC_USE_GEOMETRY_RENDERER + js_register_cc_pipeline_ReflectionProbeFlow(ns); + js_register_cc_pipeline_ReflectionProbeStage(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_pipeline_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_pipeline_auto.h new file mode 100644 index 0000000000..352b322a26 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_pipeline_auto.h @@ -0,0 +1,599 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "renderer/pipeline/forward/ForwardPipeline.h" +#include "renderer/pipeline/forward/ForwardFlow.h" +#include "renderer/pipeline/forward/ForwardStage.h" +#include "renderer/pipeline/shadow/ShadowFlow.h" +#include "renderer/pipeline/shadow/ShadowStage.h" +#include "renderer/pipeline/shadow/CSMLayers.h" +#include "renderer/pipeline/GlobalDescriptorSetManager.h" +#include "renderer/pipeline/InstancedBuffer.h" +#include "renderer/pipeline/deferred/DeferredPipeline.h" +#include "renderer/pipeline/deferred/MainFlow.h" +#include "renderer/pipeline/deferred/GbufferStage.h" +#include "renderer/pipeline/deferred/LightingStage.h" +#include "renderer/pipeline/deferred/BloomStage.h" +#include "renderer/pipeline/deferred/PostProcessStage.h" +#include "renderer/pipeline/PipelineSceneData.h" +#include "renderer/pipeline/GeometryRenderer.h" +#include "renderer/pipeline/DebugView.h" +#include "renderer/pipeline/reflection-probe/ReflectionProbeFlow.h" +#include "renderer/pipeline/reflection-probe/ReflectionProbeStage.h" + + + +bool register_all_pipeline(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SkinningJointCapacity); +extern se::Object *__jsb_cc_pipeline_SkinningJointCapacity_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SkinningJointCapacity_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderObject); +extern se::Object *__jsb_cc_pipeline_RenderObject_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderObject_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderObject * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderTargetInfo); +extern se::Object *__jsb_cc_pipeline_RenderTargetInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderTargetInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTargetInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPass); +extern se::Object *__jsb_cc_pipeline_RenderPass_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPass_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPass * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPassDesc); +extern se::Object *__jsb_cc_pipeline_RenderPassDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPassDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPassDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderTextureDesc); +extern se::Object *__jsb_cc_pipeline_RenderTextureDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderTextureDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTextureDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::FrameBufferDesc); +extern se::Object *__jsb_cc_pipeline_FrameBufferDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_FrameBufferDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::FrameBufferDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InternalBindingDesc); +extern se::Object *__jsb_cc_pipeline_InternalBindingDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InternalBindingDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InternalBindingInst); +extern se::Object *__jsb_cc_pipeline_InternalBindingInst_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InternalBindingInst_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingInst * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderQueueCreateInfo); +extern se::Object *__jsb_cc_pipeline_RenderQueueCreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderQueueCreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderQueueCreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderQueueDesc); +extern se::Object *__jsb_cc_pipeline_RenderQueueDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderQueueDesc_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOLocalBatched); +extern se::Object *__jsb_cc_pipeline_UBOLocalBatched_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOLocalBatched_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocalBatched * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOLocal); +extern se::Object *__jsb_cc_pipeline_UBOLocal_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOLocal_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocal * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOWorldBound); +extern se::Object *__jsb_cc_pipeline_UBOWorldBound_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOWorldBound_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOWorldBound * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOForwardLight); +extern se::Object *__jsb_cc_pipeline_UBOForwardLight_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOForwardLight_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOForwardLight * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBODeferredLight); +extern se::Object *__jsb_cc_pipeline_UBODeferredLight_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBODeferredLight_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBODeferredLight * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSkinningTexture); +extern se::Object *__jsb_cc_pipeline_UBOSkinningTexture_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSkinningTexture_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningTexture * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSkinningAnimation); +extern se::Object *__jsb_cc_pipeline_UBOSkinningAnimation_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSkinningAnimation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningAnimation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSkinning); +extern se::Object *__jsb_cc_pipeline_UBOSkinning_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSkinning_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinning * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOMorph); +extern se::Object *__jsb_cc_pipeline_UBOMorph_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOMorph_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOMorph * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOUILocal); +extern se::Object *__jsb_cc_pipeline_UBOUILocal_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOUILocal_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOUILocal * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSH); +extern se::Object *__jsb_cc_pipeline_UBOSH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOGlobal); +extern se::Object *__jsb_cc_pipeline_UBOGlobal_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOGlobal_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOGlobal * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOCamera); +extern se::Object *__jsb_cc_pipeline_UBOCamera_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOCamera_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCamera * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOShadow); +extern se::Object *__jsb_cc_pipeline_UBOShadow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOShadow_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOShadow * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOCSM); +extern se::Object *__jsb_cc_pipeline_UBOCSM_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOCSM_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCSM * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DescriptorSetLayoutInfos); +extern se::Object *__jsb_cc_pipeline_DescriptorSetLayoutInfos_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DescriptorSetLayoutInfos_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DescriptorSetLayoutInfos * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SHADOWMAP); +extern se::Object *__jsb_cc_pipeline_SHADOWMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SHADOWMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SHADOWMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ENVIRONMENT); +extern se::Object *__jsb_cc_pipeline_ENVIRONMENT_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ENVIRONMENT_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::ENVIRONMENT * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SPOTSHADOWMAP); +extern se::Object *__jsb_cc_pipeline_SPOTSHADOWMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SPOTSHADOWMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPOTSHADOWMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DIFFUSEMAP); +extern se::Object *__jsb_cc_pipeline_DIFFUSEMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DIFFUSEMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DIFFUSEMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::JOINTTEXTURE); +extern se::Object *__jsb_cc_pipeline_JOINTTEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_JOINTTEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::JOINTTEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REALTIMEJOINTTEXTURE); +extern se::Object *__jsb_cc_pipeline_REALTIMEJOINTTEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REALTIMEJOINTTEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::POSITIONMORPH); +extern se::Object *__jsb_cc_pipeline_POSITIONMORPH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_POSITIONMORPH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::POSITIONMORPH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::NORMALMORPH); +extern se::Object *__jsb_cc_pipeline_NORMALMORPH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_NORMALMORPH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::NORMALMORPH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::TANGENTMORPH); +extern se::Object *__jsb_cc_pipeline_TANGENTMORPH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_TANGENTMORPH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::TANGENTMORPH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::LIGHTMAPTEXTURE); +extern se::Object *__jsb_cc_pipeline_LIGHTMAPTEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_LIGHTMAPTEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::LIGHTMAPTEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SPRITETEXTURE); +extern se::Object *__jsb_cc_pipeline_SPRITETEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SPRITETEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPRITETEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBECUBEMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBECUBEMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBEPLANARMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEPLANARMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBEDATAMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEDATAMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPipelineInfo); +extern se::Object *__jsb_cc_pipeline_RenderPipelineInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPipelineInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPipelineInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPipeline); +extern se::Object *__jsb_cc_pipeline_RenderPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderFlowInfo); +extern se::Object *__jsb_cc_pipeline_RenderFlowInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderFlowInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderFlowInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderFlow); +extern se::Object *__jsb_cc_pipeline_RenderFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderStageInfo); +extern se::Object *__jsb_cc_pipeline_RenderStageInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderStageInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderStageInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderStage); +extern se::Object *__jsb_cc_pipeline_RenderStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DebugView); +extern se::Object *__jsb_cc_pipeline_DebugView_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DebugView_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ForwardPipeline); +extern se::Object *__jsb_cc_pipeline_ForwardPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ForwardPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ForwardFlow); +extern se::Object *__jsb_cc_pipeline_ForwardFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ForwardFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ForwardStage); +extern se::Object *__jsb_cc_pipeline_ForwardStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ForwardStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ShadowFlow); +extern se::Object *__jsb_cc_pipeline_ShadowFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ShadowFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ShadowStage); +extern se::Object *__jsb_cc_pipeline_ShadowStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ShadowStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ShadowTransformInfo); +extern se::Object *__jsb_cc_pipeline_ShadowTransformInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ShadowTransformInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::CSMLayerInfo); +extern se::Object *__jsb_cc_pipeline_CSMLayerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_CSMLayerInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::CSMLayers); +extern se::Object *__jsb_cc_pipeline_CSMLayers_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_CSMLayers_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::GlobalDSManager); +extern se::Object *__jsb_cc_pipeline_GlobalDSManager_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_GlobalDSManager_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InstancedItem); +extern se::Object *__jsb_cc_pipeline_InstancedItem_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InstancedItem_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InstancedItem * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InstancedBuffer); +extern se::Object *__jsb_cc_pipeline_InstancedBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InstancedBuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DeferredPipeline); +extern se::Object *__jsb_cc_pipeline_DeferredPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DeferredPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::MainFlow); +extern se::Object *__jsb_cc_pipeline_MainFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_MainFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::GbufferStage); +extern se::Object *__jsb_cc_pipeline_GbufferStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_GbufferStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderElem); +extern se::Object *__jsb_cc_pipeline_RenderElem_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderElem_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderElem * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::LightingStage); +extern se::Object *__jsb_cc_pipeline_LightingStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_LightingStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::BloomStage); +extern se::Object *__jsb_cc_pipeline_BloomStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_BloomStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::PostProcessStage); +extern se::Object *__jsb_cc_pipeline_PostProcessStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_PostProcessStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::PipelineSceneData); +extern se::Object *__jsb_cc_pipeline_PipelineSceneData_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_PipelineSceneData_class; // NOLINT + +#if CC_USE_GEOMETRY_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::GeometryRenderer); +extern se::Object *__jsb_cc_pipeline_GeometryRenderer_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_GeometryRenderer_class; // NOLINT + +#endif // CC_USE_GEOMETRY_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ReflectionProbeFlow); +extern se::Object *__jsb_cc_pipeline_ReflectionProbeFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ReflectionProbeFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ReflectionProbeStage); +extern se::Object *__jsb_cc_pipeline_ReflectionProbeStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ReflectionProbeStage_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_render_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_render_auto.cpp new file mode 100644 index 0000000000..dafc2887a6 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_render_auto.cpp @@ -0,0 +1,9824 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_render_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "renderer/pipeline/GeometryRenderer.h" +#include "renderer/pipeline/GlobalDescriptorSetManager.h" +#include "renderer/pipeline/custom/RenderCommonJsb.h" + +using namespace cc; +using namespace cc::render; + + +#define cc_render_PipelineRuntime_device_get(self_) self_->getDevice() + + +#define cc_render_PipelineRuntime_macros_get(self_) self_->getMacros() + + +#define cc_render_PipelineRuntime_globalDSManager_get(self_) self_->getGlobalDSManager() + + +#define cc_render_PipelineRuntime_descriptorSetLayout_get(self_) self_->getDescriptorSetLayout() + + +#define cc_render_PipelineRuntime_descriptorSet_get(self_) self_->getDescriptorSet() + + +#define cc_render_PipelineRuntime_commandBuffers_get(self_) self_->getCommandBuffers() + + +#define cc_render_PipelineRuntime_pipelineSceneData_get(self_) self_->getPipelineSceneData() + + +#define cc_render_PipelineRuntime_constantMacros_get(self_) self_->getConstantMacros() + + +#define cc_render_PipelineRuntime_profiler_get(self_) self_->getProfiler() +#define cc_render_PipelineRuntime_profiler_set(self_, val_) self_->setProfiler(val_) + + +#define cc_render_PipelineRuntime_geometryRenderer_get(self_) self_->getGeometryRenderer() + + +#define cc_render_PipelineRuntime_shadingScale_get(self_) self_->getShadingScale() +#define cc_render_PipelineRuntime_shadingScale_set(self_, val_) self_->setShadingScale(val_) + + +#define cc_render_RenderNode_name_get(self_) self_->getName() +#define cc_render_RenderNode_name_set(self_, val_) self_->setName(val_) + + +#define cc_render_BasicRenderPassBuilder_showStatistics_get(self_) self_->getShowStatistics() +#define cc_render_BasicRenderPassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_) + + +#define cc_render_BasicPipeline_type_get(self_) self_->getType() + + +#define cc_render_BasicPipeline_capabilities_get(self_) self_->getCapabilities() + + +#define cc_render_BasicPipeline_enableCpuLightCulling_get(self_) self_->getEnableCpuLightCulling() +#define cc_render_BasicPipeline_enableCpuLightCulling_set(self_, val_) self_->setEnableCpuLightCulling(val_) + + +#define cc_render_RenderSubpassBuilder_showStatistics_get(self_) self_->getShowStatistics() +#define cc_render_RenderSubpassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_) + + + +se::Class* __jsb_cc_render_PipelineRuntime_class = nullptr; +se::Object* __jsb_cc_render_PipelineRuntime_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineRuntime) + +static bool js_delete_cc_render_PipelineRuntime(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelineRuntime) + +static bool js_cc_render_PipelineRuntime_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ; + gfx::Swapchain *arg2 = (gfx::Swapchain *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(cls); + + __jsb_cc_render_PipelineRuntime_proto = cls->getProto(); + __jsb_cc_render_PipelineRuntime_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_render_any(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::SubpassCapabilities arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::render::any(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_any) + +se::Class* __jsb_cc_render_PipelineCapabilities_class = nullptr; +se::Object* __jsb_cc_render_PipelineCapabilities_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineCapabilities) + +static bool js_cc_render_PipelineCapabilities_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineCapabilities *arg1 = (cc::render::PipelineCapabilities *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_PipelineCapabilities_subpass_set) + +static bool js_cc_render_PipelineCapabilities_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::PipelineCapabilities *arg1 = (cc::render::PipelineCapabilities *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_PipelineCapabilities_subpass_get) + +static bool js_new_cc_render_PipelineCapabilities(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::render::PipelineCapabilities *result; + result = (cc::render::PipelineCapabilities *)new cc::render::PipelineCapabilities(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_render_PipelineCapabilities, __jsb_cc_render_PipelineCapabilities_class, js_delete_cc_render_PipelineCapabilities) + +static bool js_delete_cc_render_PipelineCapabilities(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelineCapabilities) + +template<> +bool sevalue_to_native(const se::Value &from, cc::render::PipelineCapabilities * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + return ok; +} + + +bool js_register_cc_render_PipelineCapabilities(se::Object* obj) { + auto* cls = se::Class::create("PipelineCapabilities", obj, nullptr, _SE(js_new_cc_render_PipelineCapabilities)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("subpass", _SE(js_cc_render_PipelineCapabilities_subpass_get), _SE(js_cc_render_PipelineCapabilities_subpass_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineCapabilities)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_PipelineCapabilities_proto = cls->getProto(); + __jsb_cc_render_PipelineCapabilities_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderNode_class = nullptr; +se::Object* __jsb_cc_render_RenderNode_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderNode) + +static bool js_delete_cc_render_RenderNode(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderNode) + +static bool js_cc_render_RenderNode_setCustomBehavior(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderNode *arg1 = (cc::render::RenderNode *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setCustomBehavior((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderNode_setCustomBehavior) + +static bool js_cc_render_RenderNode_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderNode *arg1 = (cc::render::RenderNode *) NULL ; + ccstd::string arg2 ; + + arg1 = SE_THIS_OBJECT(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(s); + if (nullptr == arg1) return true; + result = cc_render_RenderNode_name_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_RenderNode_name_get) + +bool js_register_cc_render_RenderNode(se::Object* obj) { + auto* cls = se::Class::create("RenderNode", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_render_RenderNode_name_get), _SE(js_cc_render_RenderNode_name_set)); + + cls->defineFunction("setCustomBehavior", _SE(js_cc_render_RenderNode_setCustomBehavior)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderNode)); + + + cls->install(); + JSBClassType::registerClass(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(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(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(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(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(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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFloat((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setFloat) + +static bool js_cc_render_Setter_setArrayBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + ccstd::string *arg2 = 0 ; + ArrayBuffer *arg3 = (ArrayBuffer *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setArrayBuffer((ccstd::string const &)*arg2,(ArrayBuffer const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setArrayBuffer) + +static bool js_cc_render_Setter_setBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Buffer *arg3 = (gfx::Buffer *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setTexture) + +static bool js_cc_render_Setter_setSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Sampler *arg3 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSampler((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setSampler) + +static bool js_cc_render_Setter_setBuiltinCameraConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinCameraConstants((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinCameraConstants) + +static bool js_cc_render_Setter_setBuiltinDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightConstants((cc::scene::DirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinDirectionalLightConstants) + +static bool js_cc_render_Setter_setBuiltinSphereLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSphereLightConstants((cc::scene::SphereLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSphereLightConstants) + +static bool js_cc_render_Setter_setBuiltinSpotLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightConstants((cc::scene::SpotLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSpotLightConstants) + +static bool js_cc_render_Setter_setBuiltinPointLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinPointLightConstants((cc::scene::PointLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinPointLightConstants) + +static bool js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinRangedDirectionalLightConstants((cc::scene::RangedDirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants) + +static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3,arg4); + + + return true; +} + +static bool js_cc_render_Setter_setBuiltinSpotLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightFrustumConstants((cc::scene::SpotLight const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSpotLightFrustumConstants) + +static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3); + + + return true; +} + +static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants) + +static bool js_delete_cc_render_Setter(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_Setter) + +bool js_register_cc_render_Setter(se::Object* obj) { + auto* cls = se::Class::create("Setter", obj, __jsb_cc_render_RenderNode_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setMat4", _SE(js_cc_render_Setter_setMat4)); + cls->defineFunction("setQuaternion", _SE(js_cc_render_Setter_setQuaternion)); + cls->defineFunction("setColor", _SE(js_cc_render_Setter_setColor)); + cls->defineFunction("setVec4", _SE(js_cc_render_Setter_setVec4)); + cls->defineFunction("setVec2", _SE(js_cc_render_Setter_setVec2)); + cls->defineFunction("setFloat", _SE(js_cc_render_Setter_setFloat)); + cls->defineFunction("setArrayBuffer", _SE(js_cc_render_Setter_setArrayBuffer)); + cls->defineFunction("setBuffer", _SE(js_cc_render_Setter_setBuffer)); + cls->defineFunction("setTexture", _SE(js_cc_render_Setter_setTexture)); + cls->defineFunction("setSampler", _SE(js_cc_render_Setter_setSampler)); + cls->defineFunction("setBuiltinCameraConstants", _SE(js_cc_render_Setter_setBuiltinCameraConstants)); + cls->defineFunction("setBuiltinDirectionalLightConstants", _SE(js_cc_render_Setter_setBuiltinDirectionalLightConstants)); + cls->defineFunction("setBuiltinSphereLightConstants", _SE(js_cc_render_Setter_setBuiltinSphereLightConstants)); + cls->defineFunction("setBuiltinSpotLightConstants", _SE(js_cc_render_Setter_setBuiltinSpotLightConstants)); + cls->defineFunction("setBuiltinPointLightConstants", _SE(js_cc_render_Setter_setBuiltinPointLightConstants)); + cls->defineFunction("setBuiltinRangedDirectionalLightConstants", _SE(js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants)); + cls->defineFunction("setBuiltinSpotLightFrustumConstants", _SE(js_cc_render_Setter_setBuiltinSpotLightFrustumConstants)); + cls->defineFunction("setBuiltinDirectionalLightFrustumConstants", _SE(js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_Setter)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_Setter_proto = cls->getProto(); + __jsb_cc_render_Setter_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_SceneBuilder_class = nullptr; +se::Object* __jsb_cc_render_SceneBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_SceneBuilder) + +static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ; + IntrusivePtr< cc::scene::Light > arg2 ; + uint32_t arg3 ; + cc::scene::Camera *arg4 = (cc::scene::Camera *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useLightFrustum(arg2,arg3,(cc::scene::Camera const *)arg4); + + + return true; +} + +static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ; + IntrusivePtr< cc::scene::Light > arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->useLightFrustum(arg2); + + + return true; +} + +static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ; + IntrusivePtr< cc::scene::Light > arg2 ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->useLightFrustum(arg2,arg3); + + + return true; +} + +static bool js_cc_render_SceneBuilder_useLightFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_SceneBuilder_useLightFrustum) + +static bool js_delete_cc_render_SceneBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_SceneBuilder) + +bool js_register_cc_render_SceneBuilder(se::Object* obj) { + auto* cls = se::Class::create("SceneBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("useLightFrustum", _SE(js_cc_render_SceneBuilder_useLightFrustum)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_SceneBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_SceneBuilder_proto = cls->getProto(); + __jsb_cc_render_SceneBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderQueueBuilder_class = nullptr; +se::Object* __jsb_cc_render_RenderQueueBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderQueueBuilder) + +static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + LightInfo arg3 ; + SceneFlags arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSceneOfCamera(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + SceneFlags arg3 ; + cc::scene::Light *arg4 = (cc::scene::Light *) NULL ; + cc::scene::RenderScene *arg5 = (cc::scene::RenderScene *) NULL ; + cc::render::SceneBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + Material *arg2 = (Material *) NULL ; + uint32_t arg3 ; + SceneFlags arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addFullscreenQuad(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + Material *arg3 = (Material *) NULL ; + uint32_t arg4 ; + SceneFlags arg5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCameraQuad(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + std::vector< cc::scene::Model * > *arg3 = 0 ; + SceneFlags arg4 ; + std::vector< cc::scene::Model * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDraw3D((cc::scene::Camera const *)arg2,(std::vector< cc::scene::Model * > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addDraw2D(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDraw2D((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addDraw2D) + +static bool js_cc_render_RenderQueueBuilder_addProfiler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addProfiler((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addProfiler) + +static bool js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Color *arg3 = 0 ; + ccstd::string temp2 ; + gfx::Color temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->clearRenderTarget((ccstd::string const &)*arg2,(gfx::Color const &)*arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + gfx::Viewport *arg2 = 0 ; + gfx::Viewport temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setViewport((gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_setViewport) + +static bool js_cc_render_RenderQueueBuilder_addCustomCommand(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + std::string_view arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCustomCommand(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addCustomCommand) + +static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + LightInfo arg3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSceneOfCamera(arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addSceneOfCamera) + +static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + SceneFlags arg3 ; + cc::render::SceneBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + SceneFlags arg3 ; + cc::scene::Light *arg4 = (cc::scene::Light *) NULL ; + cc::render::SceneBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addScene) + +static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + Material *arg2 = (Material *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addFullscreenQuad(arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addFullscreenQuad) + +static bool js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + Material *arg3 = (Material *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCameraQuad(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addCameraQuad(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addCameraQuad) + +static bool js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + std::vector< cc::scene::Model * > *arg3 = 0 ; + std::vector< cc::scene::Model * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addDraw3D((cc::scene::Camera const *)arg2,(std::vector< cc::scene::Model * > const &)*arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addDraw3D(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addDraw3D) + +static bool js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->clearRenderTarget((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_clearRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_clearRenderTarget) + +static bool js_delete_cc_render_RenderQueueBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderQueueBuilder) + +bool js_register_cc_render_RenderQueueBuilder(se::Object* obj) { + auto* cls = se::Class::create("RenderQueueBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addDraw2D", _SE(js_cc_render_RenderQueueBuilder_addDraw2D)); + cls->defineFunction("addProfiler", _SE(js_cc_render_RenderQueueBuilder_addProfiler)); + cls->defineFunction("setViewport", _SE(js_cc_render_RenderQueueBuilder_setViewport)); + cls->defineFunction("addCustomCommand", _SE(js_cc_render_RenderQueueBuilder_addCustomCommand)); + cls->defineFunction("addSceneOfCamera", _SE(js_cc_render_RenderQueueBuilder_addSceneOfCamera)); + cls->defineFunction("addScene", _SE(js_cc_render_RenderQueueBuilder_addScene)); + cls->defineFunction("addFullscreenQuad", _SE(js_cc_render_RenderQueueBuilder_addFullscreenQuad)); + cls->defineFunction("addCameraQuad", _SE(js_cc_render_RenderQueueBuilder_addCameraQuad)); + cls->defineFunction("addDraw3D", _SE(js_cc_render_RenderQueueBuilder_addDraw3D)); + cls->defineFunction("clearRenderTarget", _SE(js_cc_render_RenderQueueBuilder_clearRenderTarget)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderQueueBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_RenderQueueBuilder_proto = cls->getProto(); + __jsb_cc_render_RenderQueueBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_BasicRenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_BasicRenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicRenderPassBuilder) + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + gfx::Color *arg5 = 0 ; + ccstd::string temp2 ; + gfx::Color temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,(gfx::Color const &)*arg5); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + float arg5 ; + uint8_t arg6 ; + gfx::ClearFlagBit arg7 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp3 ; + ccstd::string temp4 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + gfx::Viewport *arg2 = 0 ; + gfx::Viewport temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setViewport((gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_setViewport) + +static bool js_cc_render_BasicRenderPassBuilder_setVersion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + uint64_t arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setVersion((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_setVersion) + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addRenderTarget) + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addDepthStencil((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + float arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + float arg5 ; + uint8_t arg6 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addDepthStencil) + +static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addTexture) + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + QueueHint arg2 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addQueue) + +static bool js_cc_render_BasicRenderPassBuilder_showStatistics_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_render_BasicRenderPassBuilder_showStatistics_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_BasicRenderPassBuilder_showStatistics_set) + +static bool js_cc_render_BasicRenderPassBuilder_showStatistics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_render_BasicRenderPassBuilder_showStatistics_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicRenderPassBuilder_showStatistics_get) + +static bool js_delete_cc_render_BasicRenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_BasicRenderPassBuilder) + +bool js_register_cc_render_BasicRenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("BasicRenderPassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("showStatistics", _SE(js_cc_render_BasicRenderPassBuilder_showStatistics_get), _SE(js_cc_render_BasicRenderPassBuilder_showStatistics_set)); + + cls->defineFunction("setViewport", _SE(js_cc_render_BasicRenderPassBuilder_setViewport)); + cls->defineFunction("setVersion", _SE(js_cc_render_BasicRenderPassBuilder_setVersion)); + cls->defineFunction("addRenderTarget", _SE(js_cc_render_BasicRenderPassBuilder_addRenderTarget)); + cls->defineFunction("addDepthStencil", _SE(js_cc_render_BasicRenderPassBuilder_addDepthStencil)); + cls->defineFunction("addTexture", _SE(js_cc_render_BasicRenderPassBuilder_addTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_BasicRenderPassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicRenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_BasicRenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_BasicRenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_BasicMultisampleRenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicMultisampleRenderPassBuilder) + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget) + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + gfx::ResolveMode arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil) + +static bool js_delete_cc_render_BasicMultisampleRenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_BasicMultisampleRenderPassBuilder) + +bool js_register_cc_render_BasicMultisampleRenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("BasicMultisampleRenderPassBuilder", obj, __jsb_cc_render_BasicRenderPassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("resolveRenderTarget", _SE(js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget)); + cls->defineFunction("resolveDepthStencil", _SE(js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicMultisampleRenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_BasicMultisampleRenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_BasicPipeline_class = nullptr; +se::Object* __jsb_cc_render_BasicPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicPipeline) + +static bool js_cc_render_BasicPipeline_beginSetup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSetup(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_beginSetup) + +static bool js_cc_render_BasicPipeline_endSetup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endSetup(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_endSetup) + +static bool js_cc_render_BasicPipeline_containsResource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)((cc::render::BasicPipeline const *)arg1)->containsResource((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_containsResource) + +static bool js_cc_render_BasicPipeline_addRenderWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *arg7 = 0 ; + ccstd::string temp2 ; + ccstd::string temp7 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + result = (arg1)->addRenderWindow((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,(ccstd::string const &)*arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->updateRenderWindow((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ResourceResidency arg6 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ResourceResidency arg6 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + gfx::Format arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + gfx::Format arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ResourceFlags arg4 ; + ResourceResidency arg5 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addBuffer((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addBuffer) + +static bool js_cc_render_BasicPipeline_updateBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateBuffer((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateBuffer) + +static bool js_cc_render_BasicPipeline_addExternalTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Texture *arg3 = (gfx::Texture *) NULL ; + ResourceFlags arg4 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addExternalTexture((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addExternalTexture) + +static bool js_cc_render_BasicPipeline_updateExternalTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Texture *arg3 = (gfx::Texture *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateExternalTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateExternalTexture) + +static bool js_cc_render_BasicPipeline_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::TextureType arg3 ; + gfx::Format arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + uint32_t arg9 ; + gfx::SampleCount arg10 ; + ResourceFlags arg11 ; + ResourceResidency arg12 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 11) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 11); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[9], &arg11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[10], &arg12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addTexture) + +static bool js_cc_render_BasicPipeline_updateTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + gfx::SampleCount arg9 ; + ccstd::string temp2 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateTexture) + +static bool js_cc_render_BasicPipeline_addResource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ResourceDimension arg3 ; + gfx::Format arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + uint32_t arg9 ; + gfx::SampleCount arg10 ; + ResourceFlags arg11 ; + ResourceResidency arg12 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 11) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 11); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[9], &arg11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[10], &arg12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addResource((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addResource) + +static bool js_cc_render_BasicPipeline_updateResource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + gfx::SampleCount arg9 ; + ccstd::string temp2 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateResource((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateResource) + +static bool js_cc_render_BasicPipeline_beginFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginFrame(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_beginFrame) + +static bool js_cc_render_BasicPipeline_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_update) + +static bool js_cc_render_BasicPipeline_endFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endFrame(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_endFrame) + +static bool js_cc_render_BasicPipeline_addRenderPass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp4 ; + cc::render::BasicRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::BasicRenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string *arg6 = 0 ; + ccstd::string temp6 ; + cc::render::BasicMultisampleRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (cc::render::BasicMultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5,(ccstd::string const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addResolvePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::vector< ResolvePair > *arg2 = 0 ; + ccstd::vector< ResolvePair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addResolvePass((ccstd::vector< ResolvePair > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addResolvePass) + +static bool js_cc_render_BasicPipeline_addCopyPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::vector< CopyPair > *arg2 = 0 ; + ccstd::vector< CopyPair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addCopyPass((ccstd::vector< CopyPair > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addCopyPass) + +static bool js_cc_render_BasicPipeline_addBuiltinReflectionProbePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBuiltinReflectionProbePass((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addBuiltinReflectionProbePass) + +static bool js_cc_render_BasicPipeline_getDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + UpdateFrequency arg3 ; + ccstd::string temp2 ; + gfx::DescriptorSetLayout *result = 0 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout((ccstd::string const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_getDescriptorSetLayout) + +static bool js_cc_render_BasicPipeline_setMat4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setMat4) + +static bool js_cc_render_BasicPipeline_setQuaternion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setQuaternion) + +static bool js_cc_render_BasicPipeline_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::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(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_BasicPipeline_setColor) + +static bool js_cc_render_BasicPipeline_setVec4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setVec4) + +static bool js_cc_render_BasicPipeline_setVec2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setVec2) + +static bool js_cc_render_BasicPipeline_setFloat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setFloat) + +static bool js_cc_render_BasicPipeline_setArrayBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ArrayBuffer *arg3 = (ArrayBuffer *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setArrayBuffer((ccstd::string const &)*arg2,(ArrayBuffer const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setArrayBuffer) + +static bool js_cc_render_BasicPipeline_setBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::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(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_BasicPipeline_setBuffer) + +static bool js_cc_render_BasicPipeline_setTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Texture *arg3 = (gfx::Texture *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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_BasicPipeline_setTexture) + +static bool js_cc_render_BasicPipeline_setSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::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(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_BasicPipeline_setSampler) + +static bool js_cc_render_BasicPipeline_setBuiltinCameraConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinCameraConstants((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinCameraConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightConstants((cc::scene::DirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinDirectionalLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinSphereLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSphereLightConstants((cc::scene::SphereLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinSphereLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinSpotLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightConstants((cc::scene::SpotLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinSpotLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinPointLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinPointLightConstants((cc::scene::PointLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinPointLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinRangedDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinRangedDirectionalLightConstants((cc::scene::RangedDirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinRangedDirectionalLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_setBuiltinSpotLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightFrustumConstants((cc::scene::SpotLight const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinSpotLightFrustumConstants) + +static bool js_cc_render_BasicPipeline_addRenderWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->addRenderWindow((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_render_BasicPipeline_addRenderWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addRenderWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderWindow) + +static bool js_cc_render_BasicPipeline_updateRenderWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateRenderWindow((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicPipeline_updateRenderWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicPipeline_updateRenderWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateRenderWindow) + +static bool js_cc_render_BasicPipeline_addRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicPipeline_addRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderTarget) + +static bool js_cc_render_BasicPipeline_addDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicPipeline_addDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addDepthStencil) + +static bool js_cc_render_BasicPipeline_updateRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicPipeline_updateRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicPipeline_updateRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateRenderTarget) + +static bool js_cc_render_BasicPipeline_updateDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicPipeline_updateDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicPipeline_updateDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateDepthStencil) + +static bool js_cc_render_BasicPipeline_addRenderPass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::render::BasicRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::BasicRenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicPipeline_addRenderPass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicPipeline_addRenderPass__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderPass) + +static bool js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::render::BasicMultisampleRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::BasicMultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addMultisampleRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addMultisampleRenderPass) + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3); + + + return true; +} + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants) + +static bool js_cc_render_BasicPipeline_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::render::PipelineType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::PipelineType)cc_render_BasicPipeline_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicPipeline_type_get) + +static bool js_cc_render_BasicPipeline_capabilities_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::render::PipelineCapabilities result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_render_BasicPipeline_capabilities_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicPipeline_capabilities_get) + +static bool js_cc_render_BasicPipeline_enableCpuLightCulling_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_render_BasicPipeline_enableCpuLightCulling_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_BasicPipeline_enableCpuLightCulling_set) + +static bool js_cc_render_BasicPipeline_enableCpuLightCulling_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_render_BasicPipeline_enableCpuLightCulling_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicPipeline_enableCpuLightCulling_get) + +static bool js_delete_cc_render_BasicPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_BasicPipeline) + +bool js_register_cc_render_BasicPipeline(se::Object* obj) { + auto* cls = se::Class::create("BasicPipeline", obj, __jsb_cc_render_PipelineRuntime_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_render_BasicPipeline_type_get), nullptr); + cls->defineProperty("capabilities", _SE(js_cc_render_BasicPipeline_capabilities_get), nullptr); + cls->defineProperty("enableCpuLightCulling", _SE(js_cc_render_BasicPipeline_enableCpuLightCulling_get), _SE(js_cc_render_BasicPipeline_enableCpuLightCulling_set)); + + cls->defineFunction("beginSetup", _SE(js_cc_render_BasicPipeline_beginSetup)); + cls->defineFunction("endSetup", _SE(js_cc_render_BasicPipeline_endSetup)); + cls->defineFunction("containsResource", _SE(js_cc_render_BasicPipeline_containsResource)); + cls->defineFunction("addBuffer", _SE(js_cc_render_BasicPipeline_addBuffer)); + cls->defineFunction("updateBuffer", _SE(js_cc_render_BasicPipeline_updateBuffer)); + cls->defineFunction("addExternalTexture", _SE(js_cc_render_BasicPipeline_addExternalTexture)); + cls->defineFunction("updateExternalTexture", _SE(js_cc_render_BasicPipeline_updateExternalTexture)); + cls->defineFunction("addTexture", _SE(js_cc_render_BasicPipeline_addTexture)); + cls->defineFunction("updateTexture", _SE(js_cc_render_BasicPipeline_updateTexture)); + cls->defineFunction("addResource", _SE(js_cc_render_BasicPipeline_addResource)); + cls->defineFunction("updateResource", _SE(js_cc_render_BasicPipeline_updateResource)); + cls->defineFunction("beginFrame", _SE(js_cc_render_BasicPipeline_beginFrame)); + cls->defineFunction("update", _SE(js_cc_render_BasicPipeline_update)); + cls->defineFunction("endFrame", _SE(js_cc_render_BasicPipeline_endFrame)); + cls->defineFunction("addResolvePass", _SE(js_cc_render_BasicPipeline_addResolvePass)); + cls->defineFunction("addCopyPass", _SE(js_cc_render_BasicPipeline_addCopyPass)); + cls->defineFunction("addBuiltinReflectionProbePass", _SE(js_cc_render_BasicPipeline_addBuiltinReflectionProbePass)); + cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_render_BasicPipeline_getDescriptorSetLayout)); + cls->defineFunction("setMat4", _SE(js_cc_render_BasicPipeline_setMat4)); + cls->defineFunction("setQuaternion", _SE(js_cc_render_BasicPipeline_setQuaternion)); + cls->defineFunction("setColor", _SE(js_cc_render_BasicPipeline_setColor)); + cls->defineFunction("setVec4", _SE(js_cc_render_BasicPipeline_setVec4)); + cls->defineFunction("setVec2", _SE(js_cc_render_BasicPipeline_setVec2)); + cls->defineFunction("setFloat", _SE(js_cc_render_BasicPipeline_setFloat)); + cls->defineFunction("setArrayBuffer", _SE(js_cc_render_BasicPipeline_setArrayBuffer)); + cls->defineFunction("setBuffer", _SE(js_cc_render_BasicPipeline_setBuffer)); + cls->defineFunction("setTexture", _SE(js_cc_render_BasicPipeline_setTexture)); + cls->defineFunction("setSampler", _SE(js_cc_render_BasicPipeline_setSampler)); + cls->defineFunction("setBuiltinCameraConstants", _SE(js_cc_render_BasicPipeline_setBuiltinCameraConstants)); + cls->defineFunction("setBuiltinDirectionalLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinDirectionalLightConstants)); + cls->defineFunction("setBuiltinSphereLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinSphereLightConstants)); + cls->defineFunction("setBuiltinSpotLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinSpotLightConstants)); + cls->defineFunction("setBuiltinPointLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinPointLightConstants)); + cls->defineFunction("setBuiltinRangedDirectionalLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinRangedDirectionalLightConstants)); + cls->defineFunction("setBuiltinSpotLightFrustumConstants", _SE(js_cc_render_BasicPipeline_setBuiltinSpotLightFrustumConstants)); + cls->defineFunction("addRenderWindow", _SE(js_cc_render_BasicPipeline_addRenderWindow)); + cls->defineFunction("updateRenderWindow", _SE(js_cc_render_BasicPipeline_updateRenderWindow)); + cls->defineFunction("addRenderTarget", _SE(js_cc_render_BasicPipeline_addRenderTarget)); + cls->defineFunction("addDepthStencil", _SE(js_cc_render_BasicPipeline_addDepthStencil)); + cls->defineFunction("updateRenderTarget", _SE(js_cc_render_BasicPipeline_updateRenderTarget)); + cls->defineFunction("updateDepthStencil", _SE(js_cc_render_BasicPipeline_updateDepthStencil)); + cls->defineFunction("addRenderPass", _SE(js_cc_render_BasicPipeline_addRenderPass)); + cls->defineFunction("addMultisampleRenderPass", _SE(js_cc_render_BasicPipeline_addMultisampleRenderPass)); + cls->defineFunction("setBuiltinDirectionalLightFrustumConstants", _SE(js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_BasicPipeline_proto = cls->getProto(); + __jsb_cc_render_BasicPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderSubpassBuilder_class = nullptr; +se::Object* __jsb_cc_render_RenderSubpassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderSubpassBuilder) + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + gfx::LoadOp arg5 ; + gfx::StoreOp arg6 ; + gfx::Color *arg7 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + gfx::Color temp7 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5,arg6,(gfx::Color const &)*arg7); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + float arg8 ; + uint8_t arg9 ; + gfx::ClearFlagBit arg10 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addStorageBuffer) + +static bool js_cc_render_RenderSubpassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addStorageImage) + +static bool js_cc_render_RenderSubpassBuilder_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + gfx::Viewport *arg2 = 0 ; + gfx::Viewport temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setViewport((gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_setViewport) + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp3 ; + ccstd::string temp4 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_setCustomShaderStages) + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + gfx::LoadOp arg5 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + gfx::LoadOp arg5 ; + gfx::StoreOp arg6 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addRenderTarget) + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + float arg8 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + float arg8 ; + uint8_t arg9 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addDepthStencil) + +static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addTexture) + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + QueueHint arg2 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addQueue) + +static bool js_cc_render_RenderSubpassBuilder_showStatistics_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_render_RenderSubpassBuilder_showStatistics_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_RenderSubpassBuilder_showStatistics_set) + +static bool js_cc_render_RenderSubpassBuilder_showStatistics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_render_RenderSubpassBuilder_showStatistics_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_RenderSubpassBuilder_showStatistics_get) + +static bool js_delete_cc_render_RenderSubpassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderSubpassBuilder) + +bool js_register_cc_render_RenderSubpassBuilder(se::Object* obj) { + auto* cls = se::Class::create("RenderSubpassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("showStatistics", _SE(js_cc_render_RenderSubpassBuilder_showStatistics_get), _SE(js_cc_render_RenderSubpassBuilder_showStatistics_set)); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_RenderSubpassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_RenderSubpassBuilder_addStorageImage)); + cls->defineFunction("setViewport", _SE(js_cc_render_RenderSubpassBuilder_setViewport)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_RenderSubpassBuilder_setCustomShaderStages)); + cls->defineFunction("addRenderTarget", _SE(js_cc_render_RenderSubpassBuilder_addRenderTarget)); + cls->defineFunction("addDepthStencil", _SE(js_cc_render_RenderSubpassBuilder_addDepthStencil)); + cls->defineFunction("addTexture", _SE(js_cc_render_RenderSubpassBuilder_addTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_RenderSubpassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderSubpassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_RenderSubpassBuilder_proto = cls->getProto(); + __jsb_cc_render_RenderSubpassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_MultisampleRenderSubpassBuilder_class = nullptr; +se::Object* __jsb_cc_render_MultisampleRenderSubpassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderSubpassBuilder) + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget) + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + gfx::ResolveMode arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil) + +static bool js_delete_cc_render_MultisampleRenderSubpassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderSubpassBuilder) + +bool js_register_cc_render_MultisampleRenderSubpassBuilder(se::Object* obj) { + auto* cls = se::Class::create("MultisampleRenderSubpassBuilder", obj, __jsb_cc_render_RenderSubpassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("resolveRenderTarget", _SE(js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget)); + cls->defineFunction("resolveDepthStencil", _SE(js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_MultisampleRenderSubpassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_MultisampleRenderSubpassBuilder_proto = cls->getProto(); + __jsb_cc_render_MultisampleRenderSubpassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_ComputeQueueBuilder_class = nullptr; +se::Object* __jsb_cc_render_ComputeQueueBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputeQueueBuilder) + +static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + Material *arg5 = (Material *) NULL ; + uint32_t arg6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDispatch(arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDispatch(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + Material *arg5 = (Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDispatch(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_ComputeQueueBuilder_addDispatch(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputeQueueBuilder_addDispatch) + +static bool js_delete_cc_render_ComputeQueueBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_ComputeQueueBuilder) + +bool js_register_cc_render_ComputeQueueBuilder(se::Object* obj) { + auto* cls = se::Class::create("ComputeQueueBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addDispatch", _SE(js_cc_render_ComputeQueueBuilder_addDispatch)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputeQueueBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_ComputeQueueBuilder_proto = cls->getProto(); + __jsb_cc_render_ComputeQueueBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_ComputeSubpassBuilder_class = nullptr; +se::Object* __jsb_cc_render_ComputeSubpassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputeSubpassBuilder) + +static bool js_cc_render_ComputeSubpassBuilder_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addRenderTarget) + +static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addStorageBuffer) + +static bool js_cc_render_ComputeSubpassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addStorageImage) + +static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_setCustomShaderStages) + +static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addTexture) + +static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addQueue) + +static bool js_delete_cc_render_ComputeSubpassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_ComputeSubpassBuilder) + +bool js_register_cc_render_ComputeSubpassBuilder(se::Object* obj) { + auto* cls = se::Class::create("ComputeSubpassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addRenderTarget", _SE(js_cc_render_ComputeSubpassBuilder_addRenderTarget)); + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_ComputeSubpassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_ComputeSubpassBuilder_addStorageImage)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_ComputeSubpassBuilder_setCustomShaderStages)); + cls->defineFunction("addTexture", _SE(js_cc_render_ComputeSubpassBuilder_addTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_ComputeSubpassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputeSubpassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_ComputeSubpassBuilder_proto = cls->getProto(); + __jsb_cc_render_ComputeSubpassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_RenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderPassBuilder) + +static bool js_cc_render_RenderPassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addStorageBuffer) + +static bool js_cc_render_RenderPassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addStorageImage) + +static bool js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_addRenderSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::RenderSubpassBuilder *result = 0 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::RenderSubpassBuilder *)(arg1)->addRenderSubpass((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addRenderSubpass) + +static bool js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp4 ; + cc::render::MultisampleRenderSubpassBuilder *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::MultisampleRenderSubpassBuilder *)(arg1)->addMultisampleRenderSubpass(arg2,arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass) + +static bool js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputeSubpassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputeSubpassBuilder *)(arg1)->addComputeSubpass((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_setCustomShaderStages) + +static bool js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_addMaterialTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addMaterialTexture) + +static bool js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + cc::render::ComputeSubpassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::ComputeSubpassBuilder *)(arg1)->addComputeSubpass(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_addComputeSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addComputeSubpass) + +static bool js_delete_cc_render_RenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderPassBuilder) + +bool js_register_cc_render_RenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("RenderPassBuilder", obj, __jsb_cc_render_BasicRenderPassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_RenderPassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_RenderPassBuilder_addStorageImage)); + cls->defineFunction("addRenderSubpass", _SE(js_cc_render_RenderPassBuilder_addRenderSubpass)); + cls->defineFunction("addMultisampleRenderSubpass", _SE(js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_RenderPassBuilder_setCustomShaderStages)); + cls->defineFunction("addMaterialTexture", _SE(js_cc_render_RenderPassBuilder_addMaterialTexture)); + cls->defineFunction("addComputeSubpass", _SE(js_cc_render_RenderPassBuilder_addComputeSubpass)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_RenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_RenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_MultisampleRenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_MultisampleRenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderPassBuilder) + +static bool js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::MultisampleRenderPassBuilder *arg1 = (cc::render::MultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer) + +static bool js_cc_render_MultisampleRenderPassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::MultisampleRenderPassBuilder *arg1 = (cc::render::MultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderPassBuilder_addStorageImage) + +static bool js_delete_cc_render_MultisampleRenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderPassBuilder) + +bool js_register_cc_render_MultisampleRenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("MultisampleRenderPassBuilder", obj, __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_MultisampleRenderPassBuilder_addStorageImage)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_MultisampleRenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_MultisampleRenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_MultisampleRenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_ComputePassBuilder_class = nullptr; +se::Object* __jsb_cc_render_ComputePassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputePassBuilder) + +static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addStorageBuffer) + +static bool js_cc_render_ComputePassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addStorageImage) + +static bool js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_setCustomShaderStages) + +static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addTexture) + +static bool js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addMaterialTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addMaterialTexture) + +static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_ComputePassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_ComputePassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_ComputePassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addQueue) + +static bool js_delete_cc_render_ComputePassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_ComputePassBuilder) + +bool js_register_cc_render_ComputePassBuilder(se::Object* obj) { + auto* cls = se::Class::create("ComputePassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_ComputePassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_ComputePassBuilder_addStorageImage)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_ComputePassBuilder_setCustomShaderStages)); + cls->defineFunction("addTexture", _SE(js_cc_render_ComputePassBuilder_addTexture)); + cls->defineFunction("addMaterialTexture", _SE(js_cc_render_ComputePassBuilder_addMaterialTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_ComputePassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputePassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_ComputePassBuilder_proto = cls->getProto(); + __jsb_cc_render_ComputePassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_Pipeline_class = nullptr; +se::Object* __jsb_cc_render_Pipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_Pipeline) + +static bool js_cc_render_Pipeline_addStorageBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + ResourceResidency arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addStorageTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ResourceResidency arg6 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addShadingRateTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ResourceResidency arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + gfx::Format arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageBuffer((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + gfx::Format arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_Pipeline_updateShadingRateTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_updateShadingRateTexture) + +static bool js_cc_render_Pipeline_addRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp4 ; + cc::render::RenderPassBuilder *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::RenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addRenderPass) + +static bool js_cc_render_Pipeline_addMultisampleRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string *arg6 = 0 ; + ccstd::string temp6 ; + cc::render::MultisampleRenderPassBuilder *result = 0 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (cc::render::MultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5,(ccstd::string const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addMultisampleRenderPass) + +static bool js_cc_render_Pipeline_addComputePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputePassBuilder *result = 0 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputePassBuilder *)(arg1)->addComputePass((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addComputePass) + +static bool js_cc_render_Pipeline_addUploadPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::vector< UploadPair > *arg2 = 0 ; + ccstd::vector< UploadPair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addUploadPass(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addUploadPass) + +static bool js_cc_render_Pipeline_addMovePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::vector< MovePair > *arg2 = 0 ; + ccstd::vector< MovePair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addMovePass((ccstd::vector< MovePair > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addMovePass) + +static bool js_cc_render_Pipeline_addCustomBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::BufferInfo *arg3 = 0 ; + std::string *arg4 = 0 ; + ccstd::string temp2 ; + gfx::BufferInfo temp3 ; + std::string temp4 ; + uint32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (arg1)->addCustomBuffer((ccstd::string const &)*arg2,(gfx::BufferInfo const &)*arg3,(std::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addCustomBuffer) + +static bool js_cc_render_Pipeline_addCustomTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::TextureInfo *arg3 = 0 ; + std::string *arg4 = 0 ; + ccstd::string temp2 ; + gfx::TextureInfo temp3 ; + std::string temp4 ; + uint32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (arg1)->addCustomTexture((ccstd::string const &)*arg2,(gfx::TextureInfo const &)*arg3,(std::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addCustomTexture) + +static bool js_cc_render_Pipeline_addStorageBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_Pipeline_addStorageBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_Pipeline_addStorageBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addStorageBuffer) + +static bool js_cc_render_Pipeline_addStorageTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addStorageTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_Pipeline_addStorageTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_Pipeline_addStorageTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addStorageTexture) + +static bool js_cc_render_Pipeline_addShadingRateTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addShadingRateTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_Pipeline_addShadingRateTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_Pipeline_addShadingRateTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addShadingRateTexture) + +static bool js_cc_render_Pipeline_updateStorageBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageBuffer((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_Pipeline_updateStorageBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_Pipeline_updateStorageBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_updateStorageBuffer) + +static bool js_cc_render_Pipeline_updateStorageTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageTexture((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_Pipeline_updateStorageTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_Pipeline_updateStorageTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_updateStorageTexture) + +static bool js_delete_cc_render_Pipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_Pipeline) + +bool js_register_cc_render_Pipeline(se::Object* obj) { + auto* cls = se::Class::create("Pipeline", obj, __jsb_cc_render_BasicPipeline_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateShadingRateTexture", _SE(js_cc_render_Pipeline_updateShadingRateTexture)); + cls->defineFunction("addRenderPass", _SE(js_cc_render_Pipeline_addRenderPass)); + cls->defineFunction("addMultisampleRenderPass", _SE(js_cc_render_Pipeline_addMultisampleRenderPass)); + cls->defineFunction("addComputePass", _SE(js_cc_render_Pipeline_addComputePass)); + cls->defineFunction("addUploadPass", _SE(js_cc_render_Pipeline_addUploadPass)); + cls->defineFunction("addMovePass", _SE(js_cc_render_Pipeline_addMovePass)); + cls->defineFunction("addCustomBuffer", _SE(js_cc_render_Pipeline_addCustomBuffer)); + cls->defineFunction("addCustomTexture", _SE(js_cc_render_Pipeline_addCustomTexture)); + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_Pipeline_addStorageBuffer)); + cls->defineFunction("addStorageTexture", _SE(js_cc_render_Pipeline_addStorageTexture)); + cls->defineFunction("addShadingRateTexture", _SE(js_cc_render_Pipeline_addShadingRateTexture)); + cls->defineFunction("updateStorageBuffer", _SE(js_cc_render_Pipeline_updateStorageBuffer)); + cls->defineFunction("updateStorageTexture", _SE(js_cc_render_Pipeline_updateStorageTexture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_Pipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_Pipeline_proto = cls->getProto(); + __jsb_cc_render_Pipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_PipelinePassBuilder_class = nullptr; +se::Object* __jsb_cc_render_PipelinePassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelinePassBuilder) + +static bool js_delete_cc_render_PipelinePassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelinePassBuilder) + +static bool js_cc_render_PipelinePassBuilder_getConfigOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelinePassBuilder *arg1 = (cc::render::PipelinePassBuilder *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::render::PipelinePassBuilder const *)arg1)->getConfigOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelinePassBuilder_getConfigOrder) + +static bool js_cc_render_PipelinePassBuilder_getRenderOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelinePassBuilder *arg1 = (cc::render::PipelinePassBuilder *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::render::PipelinePassBuilder const *)arg1)->getRenderOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelinePassBuilder_getRenderOrder) + +bool js_register_cc_render_PipelinePassBuilder(se::Object* obj) { + auto* cls = se::Class::create("PipelinePassBuilder", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getConfigOrder", _SE(js_cc_render_PipelinePassBuilder_getConfigOrder)); + cls->defineFunction("getRenderOrder", _SE(js_cc_render_PipelinePassBuilder_getRenderOrder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelinePassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_PipelinePassBuilder_proto = cls->getProto(); + __jsb_cc_render_PipelinePassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_PipelineBuilder_class = nullptr; +se::Object* __jsb_cc_render_PipelineBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineBuilder) + +static bool js_delete_cc_render_PipelineBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelineBuilder) + +static bool js_cc_render_PipelineBuilder_windowResize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ; + cc::render::BasicPipeline *arg2 = (cc::render::BasicPipeline *) NULL ; + cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ; + cc::scene::Camera *arg4 = (cc::scene::Camera *) NULL ; + uint32_t arg5 ; + uint32_t arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->windowResize(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelineBuilder_windowResize) + +static bool js_cc_render_PipelineBuilder_setup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ; + ccstd::vector< cc::scene::Camera * > *arg2 = 0 ; + cc::render::BasicPipeline *arg3 = (cc::render::BasicPipeline *) NULL ; + ccstd::vector< cc::scene::Camera * > temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setup((ccstd::vector< cc::scene::Camera * > const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelineBuilder_setup) + +static bool js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged) + +bool js_register_cc_render_PipelineBuilder(se::Object* obj) { + auto* cls = se::Class::create("PipelineBuilder", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("windowResize", _SE(js_cc_render_PipelineBuilder_windowResize)); + cls->defineFunction("setup", _SE(js_cc_render_PipelineBuilder_setup)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineBuilder)); + + + cls->install(); + JSBClassType::registerClass(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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = ((cc::render::RenderingModule const *)arg1)->getPassID((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderingModule_getPassID) + +static bool js_cc_render_RenderingModule_getSubpassID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ; + uint32_t arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + uint32_t result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = ((cc::render::RenderingModule const *)arg1)->getSubpassID(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderingModule_getSubpassID) + +static bool js_cc_render_RenderingModule_getPhaseID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ; + uint32_t arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + uint32_t result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = ((cc::render::RenderingModule const *)arg1)->getPhaseID(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderingModule_getPhaseID) + +bool js_register_cc_render_RenderingModule(se::Object* obj) { + auto* cls = se::Class::create("RenderingModule", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getPassID", _SE(js_cc_render_RenderingModule_getPassID)); + cls->defineFunction("getSubpassID", _SE(js_cc_render_RenderingModule_getSubpassID)); + cls->defineFunction("getPhaseID", _SE(js_cc_render_RenderingModule_getPhaseID)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderingModule)); + + + cls->install(); + JSBClassType::registerClass(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(cls); + + __jsb_cc_render_Factory_proto = cls->getProto(); + __jsb_cc_render_Factory_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_render(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("render", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("render", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_render_PipelineRuntime(ns); + js_register_cc_render_PipelineCapabilities(ns); + js_register_cc_render_RenderNode(ns); + js_register_cc_render_Setter(ns); + js_register_cc_render_SceneBuilder(ns); + js_register_cc_render_RenderQueueBuilder(ns); + js_register_cc_render_BasicRenderPassBuilder(ns); + js_register_cc_render_BasicMultisampleRenderPassBuilder(ns); + js_register_cc_render_BasicPipeline(ns); + js_register_cc_render_RenderSubpassBuilder(ns); + js_register_cc_render_MultisampleRenderSubpassBuilder(ns); + js_register_cc_render_ComputeQueueBuilder(ns); + js_register_cc_render_ComputeSubpassBuilder(ns); + js_register_cc_render_RenderPassBuilder(ns); + js_register_cc_render_MultisampleRenderPassBuilder(ns); + js_register_cc_render_ComputePassBuilder(ns); + js_register_cc_render_Pipeline(ns); + js_register_cc_render_PipelinePassBuilder(ns); + js_register_cc_render_PipelineBuilder(ns); + js_register_cc_render_RenderingModule(ns); + js_register_cc_render_Factory(ns); + + /* Register global variables & global functions */ + + + + return true; +} + + +#if defined(__clang__) +#pragma clang diagnostic pop +#elif defined(__GNUC__) || defined(__GNUG__) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_render_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_render_auto.h new file mode 100644 index 0000000000..e73de7689a --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_render_auto.h @@ -0,0 +1,154 @@ +// 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. +****************************************************************************/ + +#pragma once +#include +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "renderer/pipeline/custom/RenderInterfaceTypes.h" + + + +bool register_all_render(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelineRuntime); +extern se::Object *__jsb_cc_render_PipelineRuntime_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelineRuntime_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelineCapabilities); +extern se::Object *__jsb_cc_render_PipelineCapabilities_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelineCapabilities_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::render::PipelineCapabilities * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderNode); +extern se::Object *__jsb_cc_render_RenderNode_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderNode_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::Setter); +extern se::Object *__jsb_cc_render_Setter_proto; // NOLINT +extern se::Class * __jsb_cc_render_Setter_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::SceneBuilder); +extern se::Object *__jsb_cc_render_SceneBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_SceneBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderQueueBuilder); +extern se::Object *__jsb_cc_render_RenderQueueBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderQueueBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::BasicRenderPassBuilder); +extern se::Object *__jsb_cc_render_BasicRenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_BasicRenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::BasicMultisampleRenderPassBuilder); +extern se::Object *__jsb_cc_render_BasicMultisampleRenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_BasicMultisampleRenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::BasicPipeline); +extern se::Object *__jsb_cc_render_BasicPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_render_BasicPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderSubpassBuilder); +extern se::Object *__jsb_cc_render_RenderSubpassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderSubpassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::MultisampleRenderSubpassBuilder); +extern se::Object *__jsb_cc_render_MultisampleRenderSubpassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_MultisampleRenderSubpassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::ComputeQueueBuilder); +extern se::Object *__jsb_cc_render_ComputeQueueBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_ComputeQueueBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::ComputeSubpassBuilder); +extern se::Object *__jsb_cc_render_ComputeSubpassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_ComputeSubpassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderPassBuilder); +extern se::Object *__jsb_cc_render_RenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::MultisampleRenderPassBuilder); +extern se::Object *__jsb_cc_render_MultisampleRenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_MultisampleRenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::ComputePassBuilder); +extern se::Object *__jsb_cc_render_ComputePassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_ComputePassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::Pipeline); +extern se::Object *__jsb_cc_render_Pipeline_proto; // NOLINT +extern se::Class * __jsb_cc_render_Pipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelinePassBuilder); +extern se::Object *__jsb_cc_render_PipelinePassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelinePassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelineBuilder); +extern se::Object *__jsb_cc_render_PipelineBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelineBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderingModule); +extern se::Object *__jsb_cc_render_RenderingModule_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderingModule_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::Factory); +extern se::Object *__jsb_cc_render_Factory_proto; // NOLINT +extern se::Class * __jsb_cc_render_Factory_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_scene_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_scene_auto.cpp new file mode 100644 index 0000000000..71b057048b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_scene_auto.cpp @@ -0,0 +1,30785 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_pipeline_auto.h" +#include "bindings/auto/jsb_geometry_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_render_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_2d_auto.h" + +using namespace cc; + + +#define cc_Root_device_get(self_) self_->getDevice() +#define cc_Root_device_set(self_, val_) self_->setDevice(val_) + + +#define cc_Root__device_get(self_) self_->getDevice() +#define cc_Root__device_set(self_, val_) self_->setDevice(val_) + + +#define cc_Root_mainWindow_get(self_) self_->getMainWindow() + + +#define cc_Root_curWindow_get(self_) self_->getCurWindow() +#define cc_Root_curWindow_set(self_, val_) self_->setCurWindow(val_) + + +#define cc_Root_tempWindow_get(self_) self_->getTempWindow() +#define cc_Root_tempWindow_set(self_, val_) self_->setTempWindow(val_) + + +#define cc_Root_windows_get(self_) self_->getWindows() + + +#define cc_Root_scenes_get(self_) self_->getScenes() + + +#define cc_Root_cumulativeTime_get(self_) self_->getCumulativeTime() + + +#define cc_Root_frameTime_get(self_) self_->getFrameTime() + + +#define cc_Root_frameCount_get(self_) self_->getFrameCount() + + +#define cc_Root_fps_get(self_) self_->getFps() + + +#define cc_Root_fixedFPS_get(self_) self_->getFixedFPS() +#define cc_Root_fixedFPS_set(self_, val_) self_->setFixedFPS(val_) + + +#define cc_Root_useDeferredPipeline_get(self_) self_->isUsingDeferredPipeline() + + +#define cc_Root_usesCustomPipeline_get(self_) self_->usesCustomPipeline() + + +#define cc_Root_pipeline_get(self_) self_->getPipeline() + + +#define cc_Root_customPipeline_get(self_) self_->getCustomPipeline() + + +#define cc_Root_cameraList_get(self_) self_->getCameraList() + + +#define cc_Root_debugView_get(self_) self_->getDebugView() + + +#define cc_scene_RenderWindow_width_get(self_) self_->getWidth() + + +#define cc_scene_RenderWindow_height_get(self_) self_->getHeight() + + +#define cc_scene_RenderWindow_framebuffer_get(self_) self_->getFramebuffer() + + +#define cc_scene_RenderWindow_cameras_get(self_) self_->getCameras() + + +#define cc_scene_RenderWindow_swapchain_get(self_) self_->getSwapchain() + + +#define cc_scene_RenderWindow_renderWindowId_get(self_) self_->getRenderWindowId() + + +#define cc_scene_RenderWindow_colorName_get(self_) self_->getColorName() + + +#define cc_scene_RenderWindow_depthStencilName_get(self_) self_->getDepthStencilName() + + +#define cc_scene_Pass_root_get(self_) self_->getRoot() + + +#define cc_scene_Pass_device_get(self_) self_->getDevice() + + +#define cc_scene_Pass_shaderInfo_get(self_) self_->getShaderInfo() + + +#define cc_scene_Pass_localSetLayout_get(self_) self_->getLocalSetLayout() + + +#define cc_scene_Pass_program_get(self_) self_->getProgram() + + +#define cc_scene_Pass_properties_get(self_) self_->getProperties() + + +#define cc_scene_Pass_defines_get(self_) self_->getDefines() + + +#define cc_scene_Pass_passIndex_get(self_) self_->getPassIndex() + + +#define cc_scene_Pass_propertyIndex_get(self_) self_->getPropertyIndex() + + +#define cc_scene_Pass_dynamics_get(self_) self_->getDynamics() + + +#define cc_scene_Pass_rootBufferDirty_get(self_) self_->isRootBufferDirty() + + +#define cc_scene_Pass_priority_get(self_) self_->getPriority() + + +#define cc_scene_Pass_primitive_get(self_) self_->getPrimitive() + + +#define cc_scene_Pass_stage_get(self_) self_->getStage() + + +#define cc_scene_Pass_phase_get(self_) self_->getPhase() + + +#define cc_scene_Pass_phaseID_get(self_) self_->getPhaseID() + + +#define cc_scene_Pass_rasterizerState_get(self_) self_->getRasterizerState() + + +#define cc_scene_Pass_depthStencilState_get(self_) self_->getDepthStencilState() + + +#define cc_scene_Pass_blendState_get(self_) self_->getBlendState() + + +#define cc_scene_Pass_dynamicStates_get(self_) self_->getDynamicStates() + + +#define cc_scene_Pass_batchingScheme_get(self_) self_->getBatchingScheme() + + +#define cc_scene_Pass_descriptorSet_get(self_) self_->getDescriptorSet() + + +#define cc_scene_Pass_hash_get(self_) self_->getHash() + + +#define cc_scene_Pass_pipelineLayout_get(self_) self_->getPipelineLayout() + + +#define cc_PassInstance_parent_get(self_) self_->getParent() + + +#define cc_Node_uuid_get(self_) self_->getUuid() + + +#define cc_Node_angle_get(self_) self_->getAngle() +#define cc_Node_angle_set(self_, val_) self_->setAngle(val_) + + +#define cc_Node_matrix_set(self_, val_) self_->setMatrix(val_) + + +#define cc_Node_hasChangedFlags_get(self_) self_->getChangedFlags() +#define cc_Node_hasChangedFlags_set(self_, val_) self_->setChangedFlags(val_) + + +#define cc_Node_flagChangedVersion_get(self_) self_->getFlagChangedVersion() + + +#define cc_Node__persistNode_get(self_) self_->isPersistNode() +#define cc_Node__persistNode_set(self_, val_) self_->setPersistNode(val_) + + +#define cc_Node_mobility_get(self_) self_->getMobility() +#define cc_Node_mobility_set(self_, val_) self_->setMobility(val_) + + +#define cc_Node_isSkipTransformUpdate_get(self_) self_->getIsSkipTransformUpdate() +#define cc_Node_isSkipTransformUpdate_set(self_, val_) self_->setIsSkipTransformUpdate(val_) + + +#define cc_scene_Ambient_skyColor_get(self_) self_->getSkyColor() +#define cc_scene_Ambient_skyColor_set(self_, val_) self_->setSkyColor(val_) + + +#define cc_scene_Ambient_skyIllum_get(self_) self_->getSkyIllum() +#define cc_scene_Ambient_skyIllum_set(self_, val_) self_->setSkyIllum(val_) + + +#define cc_scene_Ambient_groundAlbedo_get(self_) self_->getGroundAlbedo() +#define cc_scene_Ambient_groundAlbedo_set(self_, val_) self_->setGroundAlbedo(val_) + + +#define cc_scene_Ambient_enabled_get(self_) self_->isEnabled() +#define cc_scene_Ambient_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Ambient_mipmapCount_get(self_) self_->getMipmapCount() +#define cc_scene_Ambient_mipmapCount_set(self_, val_) self_->setMipmapCount(val_) + + +#define cc_scene_Light_baked_get(self_) self_->isBaked() +#define cc_scene_Light_baked_set(self_, val_) self_->setBaked(val_) + + +#define cc_scene_Light_color_get(self_) self_->getColor() +#define cc_scene_Light_color_set(self_, val_) self_->setColor(val_) + + +#define cc_scene_Light_useColorTemperature_get(self_) self_->isUseColorTemperature() +#define cc_scene_Light_useColorTemperature_set(self_, val_) self_->setUseColorTemperature(val_) + + +#define cc_scene_Light_colorTemperature_get(self_) self_->getColorTemperature() +#define cc_scene_Light_colorTemperature_set(self_, val_) self_->setColorTemperature(val_) + + +#define cc_scene_Light_node_get(self_) self_->getNode() +#define cc_scene_Light_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_Light_type_get(self_) self_->getType() +#define cc_scene_Light_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Light_name_get(self_) self_->getName() +#define cc_scene_Light_name_set(self_, val_) self_->setName(val_) + + +#define cc_scene_Light_scene_get(self_) self_->getScene() + + +#define cc_scene_Light_visibility_get(self_) self_->getVisibility() +#define cc_scene_Light_visibility_set(self_, val_) self_->setVisibility(val_) + + +#define cc_scene_Light_colorTemperatureRGB_get(self_) self_->getColorTemperatureRGB() +#define cc_scene_Light_colorTemperatureRGB_set(self_, val_) self_->setColorTemperatureRGB(val_) + + +#define cc_scene_LODData_screenUsagePercentage_get(self_) self_->getScreenUsagePercentage() +#define cc_scene_LODData_screenUsagePercentage_set(self_, val_) self_->setScreenUsagePercentage(val_) + + +#define cc_scene_LODData_models_get(self_) self_->getModels() + + +#define cc_scene_LODGroup_lodCount_get(self_) self_->getLodCount() + + +#define cc_scene_LODGroup_enabled_get(self_) self_->isEnabled() +#define cc_scene_LODGroup_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_LODGroup_localBoundaryCenter_get(self_) self_->getLocalBoundaryCenter() +#define cc_scene_LODGroup_localBoundaryCenter_set(self_, val_) self_->setLocalBoundaryCenter(val_) + + +#define cc_scene_LODGroup_objectSize_get(self_) self_->getObjectSize() +#define cc_scene_LODGroup_objectSize_set(self_, val_) self_->setObjectSize(val_) + + +#define cc_scene_LODGroup_node_get(self_) self_->getNode() +#define cc_scene_LODGroup_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_LODGroup_lodDataArray_get(self_) self_->getLodDataArray() + + +#define cc_scene_LODGroup_scene_get(self_) self_->getScene() + + +#define cc_scene_DirectionalLight_direction_get(self_) self_->getDirection() +#define cc_scene_DirectionalLight_direction_set(self_, val_) self_->setDirection(val_) + + +#define cc_scene_DirectionalLight_illuminance_get(self_) self_->getIlluminance() +#define cc_scene_DirectionalLight_illuminance_set(self_, val_) self_->setIlluminance(val_) + + +#define cc_scene_DirectionalLight_illuminanceHDR_get(self_) self_->getIlluminanceHDR() +#define cc_scene_DirectionalLight_illuminanceHDR_set(self_, val_) self_->setIlluminanceHDR(val_) + + +#define cc_scene_DirectionalLight_illuminanceLDR_get(self_) self_->getIlluminanceLDR() +#define cc_scene_DirectionalLight_illuminanceLDR_set(self_, val_) self_->setIlluminanceLDR(val_) + + +#define cc_scene_DirectionalLight_shadowEnabled_get(self_) self_->isShadowEnabled() +#define cc_scene_DirectionalLight_shadowEnabled_set(self_, val_) self_->setShadowEnabled(val_) + + +#define cc_scene_DirectionalLight_shadowPcf_get(self_) self_->getShadowPcf() +#define cc_scene_DirectionalLight_shadowPcf_set(self_, val_) self_->setShadowPcf(val_) + + +#define cc_scene_DirectionalLight_shadowBias_get(self_) self_->getShadowBias() +#define cc_scene_DirectionalLight_shadowBias_set(self_, val_) self_->setShadowBias(val_) + + +#define cc_scene_DirectionalLight_shadowNormalBias_get(self_) self_->getShadowNormalBias() +#define cc_scene_DirectionalLight_shadowNormalBias_set(self_, val_) self_->setShadowNormalBias(val_) + + +#define cc_scene_DirectionalLight_shadowSaturation_get(self_) self_->getShadowSaturation() +#define cc_scene_DirectionalLight_shadowSaturation_set(self_, val_) self_->setShadowSaturation(val_) + + +#define cc_scene_DirectionalLight_shadowDistance_get(self_) self_->getShadowDistance() +#define cc_scene_DirectionalLight_shadowDistance_set(self_, val_) self_->setShadowDistance(val_) + + +#define cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get(self_) self_->getShadowInvisibleOcclusionRange() +#define cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set(self_, val_) self_->setShadowInvisibleOcclusionRange(val_) + + +#define cc_scene_DirectionalLight_shadowFixedArea_get(self_) self_->isShadowFixedArea() +#define cc_scene_DirectionalLight_shadowFixedArea_set(self_, val_) self_->setShadowFixedArea(val_) + + +#define cc_scene_DirectionalLight_shadowNear_get(self_) self_->getShadowNear() +#define cc_scene_DirectionalLight_shadowNear_set(self_, val_) self_->setShadowNear(val_) + + +#define cc_scene_DirectionalLight_shadowFar_get(self_) self_->getShadowFar() +#define cc_scene_DirectionalLight_shadowFar_set(self_, val_) self_->setShadowFar(val_) + + +#define cc_scene_DirectionalLight_shadowOrthoSize_get(self_) self_->getShadowOrthoSize() +#define cc_scene_DirectionalLight_shadowOrthoSize_set(self_, val_) self_->setShadowOrthoSize(val_) + + +#define cc_scene_DirectionalLight_csmLevel_get(self_) self_->getCSMLevel() +#define cc_scene_DirectionalLight_csmLevel_set(self_, val_) self_->setCSMLevel(val_) + + +#define cc_scene_DirectionalLight_csmNeedUpdate_get(self_) self_->isCSMNeedUpdate() +#define cc_scene_DirectionalLight_csmNeedUpdate_set(self_, val_) self_->setCSMNeedUpdate(val_) + + +#define cc_scene_DirectionalLight_csmLayerLambda_get(self_) self_->getCSMLayerLambda() +#define cc_scene_DirectionalLight_csmLayerLambda_set(self_, val_) self_->setCSMLayerLambda(val_) + + +#define cc_scene_DirectionalLight_csmOptimizationMode_get(self_) self_->getCSMOptimizationMode() +#define cc_scene_DirectionalLight_csmOptimizationMode_set(self_, val_) self_->setCSMOptimizationMode(val_) + + +#define cc_scene_DirectionalLight_csmLayersTransition_get(self_) self_->getCSMLayersTransition() +#define cc_scene_DirectionalLight_csmLayersTransition_set(self_, val_) self_->setCSMLayersTransition(val_) + + +#define cc_scene_DirectionalLight_csmTransitionRange_get(self_) self_->getCSMTransitionRange() +#define cc_scene_DirectionalLight_csmTransitionRange_set(self_, val_) self_->setCSMTransitionRange(val_) + + +#define cc_scene_SpotLight_position_get(self_) self_->getPosition() + + +#define cc_scene_SpotLight_range_get(self_) self_->getRange() +#define cc_scene_SpotLight_range_set(self_, val_) self_->setRange(val_) + + +#define cc_scene_SpotLight_luminance_get(self_) self_->getLuminance() +#define cc_scene_SpotLight_luminance_set(self_, val_) self_->setLuminance(val_) + + +#define cc_scene_SpotLight_luminanceHDR_get(self_) self_->getLuminanceHDR() +#define cc_scene_SpotLight_luminanceHDR_set(self_, val_) self_->setLuminanceHDR(val_) + + +#define cc_scene_SpotLight_luminanceLDR_get(self_) self_->getLuminanceLDR() +#define cc_scene_SpotLight_luminanceLDR_set(self_, val_) self_->setLuminanceLDR(val_) + + +#define cc_scene_SpotLight_direction_get(self_) self_->getDirection() + + +#define cc_scene_SpotLight_spotAngle_get(self_) self_->getSpotAngle() +#define cc_scene_SpotLight_spotAngle_set(self_, val_) self_->setSpotAngle(val_) + + +#define cc_scene_SpotLight_angle_get(self_) self_->getAngle() + + +#define cc_scene_SpotLight_aabb_get(self_) self_->getAABB() + + +#define cc_scene_SpotLight_frustum_get(self_) self_->getFrustum() +#define cc_scene_SpotLight_frustum_set(self_, val_) self_->setFrustum(val_) + + +#define cc_scene_SpotLight_shadowEnabled_get(self_) self_->isShadowEnabled() +#define cc_scene_SpotLight_shadowEnabled_set(self_, val_) self_->setShadowEnabled(val_) + + +#define cc_scene_SpotLight_shadowPcf_get(self_) self_->getShadowPcf() +#define cc_scene_SpotLight_shadowPcf_set(self_, val_) self_->setShadowPcf(val_) + + +#define cc_scene_SpotLight_shadowBias_get(self_) self_->getShadowBias() +#define cc_scene_SpotLight_shadowBias_set(self_, val_) self_->setShadowBias(val_) + + +#define cc_scene_SpotLight_shadowNormalBias_get(self_) self_->getShadowNormalBias() +#define cc_scene_SpotLight_shadowNormalBias_set(self_, val_) self_->setShadowNormalBias(val_) + + +#define cc_scene_SpotLight_size_get(self_) self_->getSize() +#define cc_scene_SpotLight_size_set(self_, val_) self_->setSize(val_) + + +#define cc_scene_SpotLight_angleAttenuationStrength_get(self_) self_->getAngleAttenuationStrength() +#define cc_scene_SpotLight_angleAttenuationStrength_set(self_, val_) self_->setAngleAttenuationStrength(val_) + + +#define cc_scene_SphereLight_position_get(self_) self_->getPosition() +#define cc_scene_SphereLight_position_set(self_, val_) self_->setPosition(val_) + + +#define cc_scene_SphereLight_size_get(self_) self_->getSize() +#define cc_scene_SphereLight_size_set(self_, val_) self_->setSize(val_) + + +#define cc_scene_SphereLight_range_get(self_) self_->getRange() +#define cc_scene_SphereLight_range_set(self_, val_) self_->setRange(val_) + + +#define cc_scene_SphereLight_luminance_get(self_) self_->getLuminance() +#define cc_scene_SphereLight_luminance_set(self_, val_) self_->setLuminance(val_) + + +#define cc_scene_SphereLight_luminanceHDR_get(self_) self_->getLuminanceHDR() +#define cc_scene_SphereLight_luminanceHDR_set(self_, val_) self_->setLuminanceHDR(val_) + + +#define cc_scene_SphereLight_luminanceLDR_get(self_) self_->getLuminanceLDR() +#define cc_scene_SphereLight_luminanceLDR_set(self_, val_) self_->setLuminanceLDR(val_) + + +#define cc_scene_SphereLight_aabb_get(self_) self_->getAABB() + + +#define cc_scene_PointLight_position_get(self_) self_->getPosition() +#define cc_scene_PointLight_position_set(self_, val_) self_->setPosition(val_) + + +#define cc_scene_PointLight_range_get(self_) self_->getRange() +#define cc_scene_PointLight_range_set(self_, val_) self_->setRange(val_) + + +#define cc_scene_PointLight_luminance_get(self_) self_->getLuminance() +#define cc_scene_PointLight_luminance_set(self_, val_) self_->setLuminance(val_) + + +#define cc_scene_PointLight_luminanceHDR_get(self_) self_->getLuminanceHDR() +#define cc_scene_PointLight_luminanceHDR_set(self_, val_) self_->setLuminanceHDR(val_) + + +#define cc_scene_PointLight_luminanceLDR_get(self_) self_->getLuminanceLDR() +#define cc_scene_PointLight_luminanceLDR_set(self_, val_) self_->setLuminanceLDR(val_) + + +#define cc_scene_PointLight_aabb_get(self_) self_->getAABB() + + +#define cc_scene_RangedDirectionalLight_illuminance_get(self_) self_->getIlluminance() +#define cc_scene_RangedDirectionalLight_illuminance_set(self_, val_) self_->setIlluminance(val_) + + +#define cc_scene_RangedDirectionalLight_illuminanceHDR_get(self_) self_->getIlluminanceHDR() +#define cc_scene_RangedDirectionalLight_illuminanceHDR_set(self_, val_) self_->setIlluminanceHDR(val_) + + +#define cc_scene_RangedDirectionalLight_illuminanceLDR_get(self_) self_->getIlluminanceLDR() +#define cc_scene_RangedDirectionalLight_illuminanceLDR_set(self_, val_) self_->setIlluminanceLDR(val_) + + +#define cc_scene_Camera_iso_get(self_) self_->getIso() +#define cc_scene_Camera_iso_set(self_, val_) self_->setIso(val_) + + +#define cc_scene_Camera_isoValue_get(self_) self_->getIsoValue() + + +#define cc_scene_Camera_ec_get(self_) self_->getEc() +#define cc_scene_Camera_ec_set(self_, val_) self_->setEc(val_) + + +#define cc_scene_Camera_exposure_get(self_) self_->getExposure() + + +#define cc_scene_Camera_shutter_get(self_) self_->getShutter() +#define cc_scene_Camera_shutter_set(self_, val_) self_->setShutter(val_) + + +#define cc_scene_Camera_shutterValue_get(self_) self_->getShutterValue() + + +#define cc_scene_Camera_apertureValue_get(self_) self_->getApertureValue() + + +#define cc_scene_Camera_width_get(self_) self_->getWidth() + + +#define cc_scene_Camera_height_get(self_) self_->getHeight() + + +#define cc_scene_Camera_aspect_get(self_) self_->getAspect() + + +#define cc_scene_Camera_scene_get(self_) self_->getScene() + + +#define cc_scene_Camera_name_get(self_) self_->getName() + + +#define cc_scene_Camera_window_get(self_) self_->getWindow() +#define cc_scene_Camera_window_set(self_, val_) self_->setWindow(val_) + + +#define cc_scene_Camera_forward_get(self_) self_->getForward() +#define cc_scene_Camera_forward_set(self_, val_) self_->setForward(val_) + + +#define cc_scene_Camera_aperture_get(self_) self_->getAperture() +#define cc_scene_Camera_aperture_set(self_, val_) self_->setAperture(val_) + + +#define cc_scene_Camera_position_get(self_) self_->getPosition() +#define cc_scene_Camera_position_set(self_, val_) self_->setPosition(val_) + + +#define cc_scene_Camera_projectionType_get(self_) self_->getProjectionType() +#define cc_scene_Camera_projectionType_set(self_, val_) self_->setProjectionType(val_) + + +#define cc_scene_Camera_fovAxis_get(self_) self_->getFovAxis() +#define cc_scene_Camera_fovAxis_set(self_, val_) self_->setFovAxis(val_) + + +#define cc_scene_Camera_fov_get(self_) self_->getFov() +#define cc_scene_Camera_fov_set(self_, val_) self_->setFov(val_) + + +#define cc_scene_Camera_nearClip_get(self_) self_->getNearClip() +#define cc_scene_Camera_nearClip_set(self_, val_) self_->setNearClip(val_) + + +#define cc_scene_Camera_farClip_get(self_) self_->getFarClip() +#define cc_scene_Camera_farClip_set(self_, val_) self_->setFarClip(val_) + + +#define cc_scene_Camera_viewport_get(self_) self_->getViewport() +#define cc_scene_Camera_viewport_set(self_, val_) self_->setViewport(val_) + + +#define cc_scene_Camera_orthoHeight_get(self_) self_->getOrthoHeight() +#define cc_scene_Camera_orthoHeight_set(self_, val_) self_->setOrthoHeight(val_) + + +#define cc_scene_Camera_clearColor_get(self_) self_->getClearColor() +#define cc_scene_Camera_clearColor_set(self_, val_) self_->setClearColor(val_) + + +#define cc_scene_Camera_clearDepth_get(self_) self_->getClearDepth() +#define cc_scene_Camera_clearDepth_set(self_, val_) self_->setClearDepth(val_) + + +#define cc_scene_Camera_clearFlag_get(self_) self_->getClearFlag() +#define cc_scene_Camera_clearFlag_set(self_, val_) self_->setClearFlag(val_) + + +#define cc_scene_Camera_clearStencil_get(self_) self_->getClearStencil() +#define cc_scene_Camera_clearStencil_set(self_, val_) self_->setClearStencil(val_) + + +#define cc_scene_Camera_enabled_get(self_) self_->isEnabled() +#define cc_scene_Camera_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Camera_exposure_get(self_) self_->getExposure() + + +#define cc_scene_Camera_frustum_get(self_) self_->getFrustum() +#define cc_scene_Camera_frustum_set(self_, val_) self_->setFrustum(val_) + + +#define cc_scene_Camera_isWindowSize_get(self_) self_->isWindowSize() +#define cc_scene_Camera_isWindowSize_set(self_, val_) self_->setWindowSize(val_) + + +#define cc_scene_Camera_priority_get(self_) self_->getPriority() +#define cc_scene_Camera_priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_scene_Camera_screenScale_get(self_) self_->getScreenScale() +#define cc_scene_Camera_screenScale_set(self_, val_) self_->setScreenScale(val_) + + +#define cc_scene_Camera_visibility_get(self_) self_->getVisibility() +#define cc_scene_Camera_visibility_set(self_, val_) self_->setVisibility(val_) + + +#define cc_scene_Camera_node_get(self_) self_->getNode() +#define cc_scene_Camera_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_Camera_surfaceTransform_get(self_) self_->getSurfaceTransform() + + +#define cc_scene_Camera_geometryRenderer_get(self_) self_->getGeometryRenderer() + + +#define cc_scene_Camera_systemWindowId_get(self_) self_->getSystemWindowId() + + +#define cc_scene_Camera_cameraUsage_get(self_) self_->getCameraUsage() +#define cc_scene_Camera_cameraUsage_set(self_, val_) self_->setCameraUsage(val_) + + +#define cc_scene_Camera_trackingType_get(self_) self_->getTrackingType() +#define cc_scene_Camera_trackingType_set(self_, val_) self_->setTrackingType(val_) + + +#define cc_scene_Camera_cameraType_get(self_) self_->getCameraType() +#define cc_scene_Camera_cameraType_set(self_, val_) self_->setCameraType(val_) + + +#define cc_scene_Camera_cameraId_get(self_) self_->getCameraId() + + +#define cc_scene_RenderScene_name_get(self_) self_->getName() + + +#define cc_scene_RenderScene_cameras_get(self_) self_->getCameras() + + +#define cc_scene_RenderScene_sphereLights_get(self_) self_->getSphereLights() + + +#define cc_scene_RenderScene_spotLights_get(self_) self_->getSpotLights() + + +#define cc_scene_RenderScene_pointLights_get(self_) self_->getPointLights() + + +#define cc_scene_RenderScene_rangedDirLights_get(self_) self_->getRangedDirLights() + + +#define cc_scene_RenderScene_models_get(self_) self_->getModels() + + +#define cc_scene_RenderScene_lodGroups_get(self_) self_->getLODGroups() + + +#define cc_scene_Skybox_model_get(self_) self_->getModel() + + +#define cc_scene_Skybox_enabled_get(self_) self_->isEnabled() +#define cc_scene_Skybox_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Skybox_useHDR_get(self_) self_->isUseHDR() +#define cc_scene_Skybox_useHDR_set(self_, val_) self_->setUseHDR(val_) + + +#define cc_scene_Skybox_useIBL_get(self_) self_->isUseIBL() +#define cc_scene_Skybox_useIBL_set(self_, val_) self_->setUseIBL(val_) + + +#define cc_scene_Skybox_useDiffuseMap_get(self_) self_->isUseDiffuseMap() +#define cc_scene_Skybox_useDiffuseMap_set(self_, val_) self_->setUseDiffuseMap(val_) + + +#define cc_scene_Skybox_isRGBE_get(self_) self_->isRGBE() + + +#define cc_scene_Skybox_envmap_get(self_) self_->getEnvmap() +#define cc_scene_Skybox_envmap_set(self_, val_) self_->setEnvmap(val_) + + +#define cc_scene_Skybox_diffuseMap_get(self_) self_->getDiffuseMap() +#define cc_scene_Skybox_diffuseMap_set(self_, val_) self_->setDiffuseMap(val_) + + +#define cc_scene_Fog_enabled_get(self_) self_->isEnabled() +#define cc_scene_Fog_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Fog_accurate_get(self_) self_->isAccurate() +#define cc_scene_Fog_accurate_set(self_, val_) self_->setAccurate(val_) + + +#define cc_scene_Fog_fogColor_get(self_) self_->getFogColor() +#define cc_scene_Fog_fogColor_set(self_, val_) self_->setFogColor(val_) + + +#define cc_scene_Fog_type_get(self_) self_->getType() +#define cc_scene_Fog_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Fog_fogDensity_get(self_) self_->getFogDensity() +#define cc_scene_Fog_fogDensity_set(self_, val_) self_->setFogDensity(val_) + + +#define cc_scene_Fog_fogStart_get(self_) self_->getFogStart() +#define cc_scene_Fog_fogStart_set(self_, val_) self_->setFogStart(val_) + + +#define cc_scene_Fog_fogEnd_get(self_) self_->getFogEnd() +#define cc_scene_Fog_fogEnd_set(self_, val_) self_->setFogEnd(val_) + + +#define cc_scene_Fog_fogAtten_get(self_) self_->getFogAtten() +#define cc_scene_Fog_fogAtten_set(self_, val_) self_->setFogAtten(val_) + + +#define cc_scene_Fog_fogTop_get(self_) self_->getFogTop() +#define cc_scene_Fog_fogTop_set(self_, val_) self_->setFogTop(val_) + + +#define cc_scene_Fog_fogRange_get(self_) self_->getFogRange() +#define cc_scene_Fog_fogRange_set(self_, val_) self_->setFogRange(val_) + + +#define cc_scene_Fog_colorArray_get(self_) self_->getColorArray() + + +#define cc_scene_Skin_enabled_get(self_) self_->isEnabled() +#define cc_scene_Skin_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Skin_blurRadius_get(self_) self_->getBlurRadius() +#define cc_scene_Skin_blurRadius_set(self_, val_) self_->setBlurRadius(val_) + + +#define cc_scene_Skin_sssIntensity_get(self_) self_->getSSSIntensity() +#define cc_scene_Skin_sssIntensity_set(self_, val_) self_->setSSSIntensity(val_) + + +#define cc_scene_PostSettings_toneMappingType_get(self_) self_->getToneMappingType() +#define cc_scene_PostSettings_toneMappingType_set(self_, val_) self_->setToneMappingType(val_) + + +#define cc_scene_Model_scene_get(self_) self_->getScene() +#define cc_scene_Model_scene_set(self_, val_) self_->setScene(val_) + + +#define cc_scene_Model__subModels_get(self_) self_->getSubModels() + + +#define cc_scene_Model_subModels_get(self_) self_->getSubModels() + + +#define cc_scene_Model_inited_get(self_) self_->isInited() + + +#define cc_scene_Model__localDataUpdated_get(self_) self_->isLocalDataUpdated() +#define cc_scene_Model__localDataUpdated_set(self_, val_) self_->setLocalDataUpdated(val_) + + +#define cc_scene_Model__worldBounds_get(self_) self_->getWorldBounds() +#define cc_scene_Model__worldBounds_set(self_, val_) self_->setWorldBounds(val_) + + +#define cc_scene_Model_worldBounds_get(self_) self_->getWorldBounds() +#define cc_scene_Model_worldBounds_set(self_, val_) self_->setWorldBounds(val_) + + +#define cc_scene_Model__modelBounds_get(self_) self_->getModelBounds() +#define cc_scene_Model__modelBounds_set(self_, val_) self_->setModelBounds(val_) + + +#define cc_scene_Model_modelBounds_get(self_) self_->getModelBounds() +#define cc_scene_Model_modelBounds_set(self_, val_) self_->setModelBounds(val_) + + +#define cc_scene_Model_worldBoundBuffer_get(self_) self_->getWorldBoundBuffer() +#define cc_scene_Model_worldBoundBuffer_set(self_, val_) self_->setWorldBoundBuffer(val_) + + +#define cc_scene_Model_localBuffer_get(self_) self_->getLocalBuffer() +#define cc_scene_Model_localBuffer_set(self_, val_) self_->setLocalBuffer(val_) + + +#define cc_scene_Model_updateStamp_get(self_) self_->getUpdateStamp() + + +#define cc_scene_Model_receiveShadow_get(self_) self_->isReceiveShadow() +#define cc_scene_Model_receiveShadow_set(self_, val_) self_->setReceiveShadow(val_) + + +#define cc_scene_Model_castShadow_get(self_) self_->isCastShadow() +#define cc_scene_Model_castShadow_set(self_, val_) self_->setCastShadow(val_) + + +#define cc_scene_Model_shadowBias_get(self_) self_->getShadowBias() +#define cc_scene_Model_shadowBias_set(self_, val_) self_->setShadowBias(val_) + + +#define cc_scene_Model_shadowNormalBias_get(self_) self_->getShadowNormalBias() +#define cc_scene_Model_shadowNormalBias_set(self_, val_) self_->setShadowNormalBias(val_) + + +#define cc_scene_Model_node_get(self_) self_->getNode() +#define cc_scene_Model_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_Model_transform_get(self_) self_->getTransform() +#define cc_scene_Model_transform_set(self_, val_) self_->setTransform(val_) + + +#define cc_scene_Model_visFlags_get(self_) self_->getVisFlags() +#define cc_scene_Model_visFlags_set(self_, val_) self_->setVisFlags(val_) + + +#define cc_scene_Model_enabled_get(self_) self_->isEnabled() +#define cc_scene_Model_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Model_type_get(self_) self_->getType() +#define cc_scene_Model_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Model_isDynamicBatching_get(self_) self_->isDynamicBatching() +#define cc_scene_Model_isDynamicBatching_set(self_, val_) self_->setDynamicBatching(val_) + + +#define cc_scene_Model_priority_get(self_) self_->getPriority() +#define cc_scene_Model_priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_scene_Model_tetrahedronIndex_get(self_) self_->getTetrahedronIndex() +#define cc_scene_Model_tetrahedronIndex_set(self_, val_) self_->setTetrahedronIndex(val_) + + +#define cc_scene_Model_useLightProbe_get(self_) self_->getUseLightProbe() +#define cc_scene_Model_useLightProbe_set(self_, val_) self_->setUseLightProbe(val_) + + +#define cc_scene_Model_bakeToReflectionProbe_get(self_) self_->getBakeToReflectionProbe() +#define cc_scene_Model_bakeToReflectionProbe_set(self_, val_) self_->setBakeToReflectionProbe(val_) + + +#define cc_scene_Model_reflectionProbeType_get(self_) self_->getReflectionProbeType() +#define cc_scene_Model_reflectionProbeType_set(self_, val_) self_->setReflectionProbeType(val_) + + +#define cc_scene_Model_receiveDirLight_get(self_) self_->isReceiveDirLight() +#define cc_scene_Model_receiveDirLight_set(self_, val_) self_->setReceiveDirLight(val_) + + +#define cc_scene_Model_reflectionProbeId_get(self_) self_->getReflectionProbeId() +#define cc_scene_Model_reflectionProbeId_set(self_, val_) self_->setReflectionProbeId(val_) + + +#define cc_scene_Model_reflectionProbeBlendId_get(self_) self_->getReflectionProbeBlendId() +#define cc_scene_Model_reflectionProbeBlendId_set(self_, val_) self_->setReflectionProbeBlendId(val_) + + +#define cc_scene_Model_reflectionProbeBlendWeight_get(self_) self_->getReflectionProbeBlendWeight() +#define cc_scene_Model_reflectionProbeBlendWeight_set(self_, val_) self_->setReflectionProbeBlendWeight(val_) + + +#define cc_scene_SubModel_passes_get(self_) self_->getPasses() +#define cc_scene_SubModel_passes_set(self_, val_) self_->setPasses(val_) + + +#define cc_scene_SubModel_shaders_get(self_) self_->getShaders() +#define cc_scene_SubModel_shaders_set(self_, val_) self_->setShaders(val_) + + +#define cc_scene_SubModel_subMesh_get(self_) self_->getSubMesh() +#define cc_scene_SubModel_subMesh_set(self_, val_) self_->setSubMesh(val_) + + +#define cc_scene_SubModel_priority_get(self_) self_->getPriority() +#define cc_scene_SubModel_priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_scene_SubModel_inputAssembler_get(self_) self_->getInputAssembler() +#define cc_scene_SubModel_inputAssembler_set(self_, val_) self_->setInputAssembler(val_) + + +#define cc_scene_SubModel_descriptorSet_get(self_) self_->getDescriptorSet() +#define cc_scene_SubModel_descriptorSet_set(self_, val_) self_->setDescriptorSet(val_) + + +#define cc_scene_SubModel_patches_get(self_) self_->getPatches() + + +#define cc_scene_ShadowsInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_ShadowsInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_ShadowsInfo_type_get(self_) self_->getType() +#define cc_scene_ShadowsInfo_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_ShadowsInfo_shadowColor_get(self_) self_->getShadowColor() +#define cc_scene_ShadowsInfo_shadowColor_set(self_, val_) self_->setShadowColor(val_) + + +#define cc_scene_ShadowsInfo_planeDirection_get(self_) self_->getPlaneDirection() +#define cc_scene_ShadowsInfo_planeDirection_set(self_, val_) self_->setPlaneDirection(val_) + + +#define cc_scene_ShadowsInfo_planeHeight_get(self_) self_->getPlaneHeight() +#define cc_scene_ShadowsInfo_planeHeight_set(self_, val_) self_->setPlaneHeight(val_) + + +#define cc_scene_ShadowsInfo_planeBias_get(self_) self_->getPlaneBias() +#define cc_scene_ShadowsInfo_planeBias_set(self_, val_) self_->setPlaneBias(val_) + + +#define cc_scene_ShadowsInfo_maxReceived_get(self_) self_->getMaxReceived() +#define cc_scene_ShadowsInfo_maxReceived_set(self_, val_) self_->setMaxReceived(val_) + + +#define cc_scene_ShadowsInfo_shadowMapSize_get(self_) self_->getShadowMapSize() +#define cc_scene_ShadowsInfo_shadowMapSize_set(self_, val_) self_->setShadowMapSize(val_) + + +#define cc_scene_Shadows_enabled_get(self_) self_->isEnabled() +#define cc_scene_Shadows_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Shadows_type_get(self_) self_->getType() +#define cc_scene_Shadows_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Shadows_normal_get(self_) self_->getNormal() +#define cc_scene_Shadows_normal_set(self_, val_) self_->setNormal(val_) + + +#define cc_scene_Shadows_distance_get(self_) self_->getDistance() +#define cc_scene_Shadows_distance_set(self_, val_) self_->setDistance(val_) + + +#define cc_scene_Shadows_planeBias_get(self_) self_->getPlaneBias() +#define cc_scene_Shadows_planeBias_set(self_, val_) self_->setPlaneBias(val_) + + +#define cc_scene_Shadows_shadowColor_get(self_) self_->getShadowColor() +#define cc_scene_Shadows_shadowColor_set(self_, val_) self_->setShadowColor(val_) + + +#define cc_scene_Shadows_maxReceived_get(self_) self_->getMaxReceived() +#define cc_scene_Shadows_maxReceived_set(self_, val_) self_->setMaxReceived(val_) + + +#define cc_scene_Shadows_size_get(self_) self_->getSize() +#define cc_scene_Shadows_size_set(self_, val_) self_->setSize(val_) + + +#define cc_scene_Shadows_shadowMapDirty_get(self_) self_->isShadowMapDirty() +#define cc_scene_Shadows_shadowMapDirty_set(self_, val_) self_->setShadowMapDirty(val_) + + +#define cc_scene_Shadows_matLight_get(self_) self_->getMatLight() + + +#define cc_scene_Shadows_material_get(self_) self_->getMaterial() + + +#define cc_scene_Shadows_instancingMaterial_get(self_) self_->getInstancingMaterial() + + +#define cc_scene_AmbientInfo_skyColor_set(self_, val_) self_->setSkyColor(val_) + + +#define cc_scene_AmbientInfo_skyIllum_get(self_) self_->getSkyIllum() +#define cc_scene_AmbientInfo_skyIllum_set(self_, val_) self_->setSkyIllum(val_) + + +#define cc_scene_AmbientInfo_groundAlbedo_set(self_, val_) self_->setGroundAlbedo(val_) + + +#define cc_scene_AmbientInfo__skyColor_get(self_) self_->getSkyColorHDR() +#define cc_scene_AmbientInfo__skyColor_set(self_, val_) self_->setSkyColorHDR(val_) + + +#define cc_scene_AmbientInfo__skyIllum_get(self_) self_->getSkyIllumHDR() +#define cc_scene_AmbientInfo__skyIllum_set(self_, val_) self_->setSkyIllumHDR(val_) + + +#define cc_scene_AmbientInfo__groundAlbedo_get(self_) self_->getGroundAlbedoHDR() +#define cc_scene_AmbientInfo__groundAlbedo_set(self_, val_) self_->setGroundAlbedoHDR(val_) + + +#define cc_scene_AmbientInfo_skyColorLDR_get(self_) self_->getSkyColorLDR() + + +#define cc_scene_AmbientInfo_groundAlbedoLDR_get(self_) self_->getGroundAlbedoLDR() + + +#define cc_scene_AmbientInfo_skyIllumLDR_get(self_) self_->getSkyIllumLDR() + + +#define cc_scene_AmbientInfo_skyLightingColor_get(self_) self_->getSkyLightingColor() +#define cc_scene_AmbientInfo_skyLightingColor_set(self_, val_) self_->setSkyLightingColor(val_) + + +#define cc_scene_AmbientInfo_groundLightingColor_get(self_) self_->getGroundLightingColor() +#define cc_scene_AmbientInfo_groundLightingColor_set(self_, val_) self_->setGroundLightingColor(val_) + + +#define cc_scene_FogInfo_type_get(self_) self_->getType() +#define cc_scene_FogInfo_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_FogInfo_fogColor_get(self_) self_->getFogColor() +#define cc_scene_FogInfo_fogColor_set(self_, val_) self_->setFogColor(val_) + + +#define cc_scene_FogInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_FogInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_FogInfo_accurate_get(self_) self_->isAccurate() +#define cc_scene_FogInfo_accurate_set(self_, val_) self_->setAccurate(val_) + + +#define cc_scene_FogInfo_fogDensity_get(self_) self_->getFogDensity() +#define cc_scene_FogInfo_fogDensity_set(self_, val_) self_->setFogDensity(val_) + + +#define cc_scene_FogInfo_fogStart_get(self_) self_->getFogStart() +#define cc_scene_FogInfo_fogStart_set(self_, val_) self_->setFogStart(val_) + + +#define cc_scene_FogInfo_fogEnd_get(self_) self_->getFogEnd() +#define cc_scene_FogInfo_fogEnd_set(self_, val_) self_->setFogEnd(val_) + + +#define cc_scene_FogInfo_fogAtten_get(self_) self_->getFogAtten() +#define cc_scene_FogInfo_fogAtten_set(self_, val_) self_->setFogAtten(val_) + + +#define cc_scene_FogInfo_fogTop_get(self_) self_->getFogTop() +#define cc_scene_FogInfo_fogTop_set(self_, val_) self_->setFogTop(val_) + + +#define cc_scene_FogInfo_fogRange_get(self_) self_->getFogRange() +#define cc_scene_FogInfo_fogRange_set(self_, val_) self_->setFogRange(val_) + + +#define cc_scene_SkyboxInfo__envmap_get(self_) self_->getEnvmapForJS() +#define cc_scene_SkyboxInfo__envmap_set(self_, val_) self_->setEnvmapForJS(val_) + + +#define cc_scene_SkyboxInfo_applyDiffuseMap_get(self_) self_->isApplyDiffuseMap() +#define cc_scene_SkyboxInfo_applyDiffuseMap_set(self_, val_) self_->setApplyDiffuseMap(val_) + + +#define cc_scene_SkyboxInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_SkyboxInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_SkyboxInfo_useIBL_get(self_) self_->isUseIBL() +#define cc_scene_SkyboxInfo_useIBL_set(self_, val_) self_->setUseIBL(val_) + + +#define cc_scene_SkyboxInfo_useHDR_get(self_) self_->isUseHDR() +#define cc_scene_SkyboxInfo_useHDR_set(self_, val_) self_->setUseHDR(val_) + + +#define cc_scene_SkyboxInfo_envmap_get(self_) self_->getEnvmap() +#define cc_scene_SkyboxInfo_envmap_set(self_, val_) self_->setEnvmap(val_) + + +#define cc_scene_SkyboxInfo_diffuseMap_get(self_) self_->getDiffuseMap() +#define cc_scene_SkyboxInfo_diffuseMap_set(self_, val_) self_->setDiffuseMap(val_) + + +#define cc_scene_SkyboxInfo_reflectionMap_get(self_) self_->getReflectionMap() +#define cc_scene_SkyboxInfo_reflectionMap_set(self_, val_) self_->setReflectionMap(val_) + + +#define cc_scene_SkyboxInfo_skyboxMaterial_get(self_) self_->getSkyboxMaterial() +#define cc_scene_SkyboxInfo_skyboxMaterial_set(self_, val_) self_->setSkyboxMaterial(val_) + + +#define cc_scene_SkyboxInfo_rotationAngle_get(self_) self_->getRotationAngle() +#define cc_scene_SkyboxInfo_rotationAngle_set(self_, val_) self_->setRotationAngle(val_) + + +#define cc_scene_SkyboxInfo_envLightingType_get(self_) self_->getEnvLightingType() +#define cc_scene_SkyboxInfo_envLightingType_set(self_, val_) self_->setEnvLightingType(val_) + + +#define cc_scene_OctreeInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_OctreeInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_OctreeInfo_minPos_get(self_) self_->getMinPos() +#define cc_scene_OctreeInfo_minPos_set(self_, val_) self_->setMinPos(val_) + + +#define cc_scene_OctreeInfo_maxPos_get(self_) self_->getMaxPos() +#define cc_scene_OctreeInfo_maxPos_set(self_, val_) self_->setMaxPos(val_) + + +#define cc_scene_OctreeInfo_depth_get(self_) self_->getDepth() +#define cc_scene_OctreeInfo_depth_set(self_, val_) self_->setDepth(val_) + + +#define cc_scene_PostSettingsInfo_toneMappingType_get(self_) self_->getToneMappingType() +#define cc_scene_PostSettingsInfo_toneMappingType_set(self_, val_) self_->setToneMappingType(val_) + + +#define cc_Scene_autoReleaseAssets_get(self_) self_->isAutoReleaseAssets() +#define cc_Scene_autoReleaseAssets_set(self_, val_) self_->setAutoReleaseAssets(val_) + + +#define cc_scene_ReflectionProbe_probeType_get(self_) self_->getProbeType() +#define cc_scene_ReflectionProbe_probeType_set(self_, val_) self_->setProbeType(val_) + + +#define cc_scene_ReflectionProbe_resolution_get(self_) self_->getResolution() +#define cc_scene_ReflectionProbe_resolution_set(self_, val_) self_->setResolution(val_) + + +#define cc_scene_ReflectionProbe_clearFlag_get(self_) self_->getClearFlag() +#define cc_scene_ReflectionProbe_clearFlag_set(self_, val_) self_->setClearFlag(val_) + + +#define cc_scene_ReflectionProbe_backgroundColor_get(self_) self_->getBackgroundColor() +#define cc_scene_ReflectionProbe_backgroundColor_set(self_, val_) self_->setBackgroundColor(val_) + + +#define cc_scene_ReflectionProbe_visibility_get(self_) self_->getVisibility() +#define cc_scene_ReflectionProbe_visibility_set(self_, val_) self_->setVisibility(val_) + + +#define cc_scene_ReflectionProbe_size_get(self_) self_->getBoudingSize() +#define cc_scene_ReflectionProbe_size_set(self_, val_) self_->setBoudingSize(val_) + + +#define cc_scene_ReflectionProbe_boundingBox_get(self_) self_->getBoundingBox() + + +#define cc_scene_ReflectionProbe_previewSphere_get(self_) self_->getPreviewSphere() +#define cc_scene_ReflectionProbe_previewSphere_set(self_, val_) self_->setPreviewSphere(val_) + + +#define cc_scene_ReflectionProbe_previewPlane_get(self_) self_->getPreviewPlane() +#define cc_scene_ReflectionProbe_previewPlane_set(self_, val_) self_->setPreviewPlane(val_) + + +#define cc_scene_ReflectionProbe_bakedCubeTextures_get(self_) self_->getBakedCubeTextures() + + +#define cc_scene_ReflectionProbe_cubemap_get(self_) self_->getCubeMap() +#define cc_scene_ReflectionProbe_cubemap_set(self_, val_) self_->setCubeMap(val_) + + +#define cc_scene_ReflectionProbe_node_get(self_) self_->getNode() + + +#define cc_scene_ReflectionProbe_realtimePlanarTexture_get(self_) self_->getRealtimePlanarTexture() + + +#define cc_scene_ReflectionProbe_camera_get(self_) self_->getCamera() + + +#define cc_SceneGlobals_bakedWithStationaryMainLight_get(self_) self_->getBakedWithStationaryMainLight() +#define cc_SceneGlobals_bakedWithStationaryMainLight_set(self_, val_) self_->setBakedWithStationaryMainLight(val_) + + +#define cc_SceneGlobals_bakedWithHighpLightmap_get(self_) self_->getBakedWithHighpLightmap() +#define cc_SceneGlobals_bakedWithHighpLightmap_set(self_, val_) self_->setBakedWithHighpLightmap(val_) + + + +static bool js_cc_hasFlag__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + cc::TransformBit arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasFlag(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAnyFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + cc::TransformBit arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAnyFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAllFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + cc::TransformBit arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAllFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_addFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit *arg1 = 0 ; + cc::TransformBit arg2 ; + cc::TransformBit temp1 ; + cc::TransformBit result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::TransformBit)cc::addFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_removeFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit *arg1 = 0 ; + cc::TransformBit arg2 ; + cc::TransformBit temp1 ; + cc::TransformBit result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::TransformBit)cc::removeFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_toNumber__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + std::underlying_type_t< cc::TransformBit > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::toNumber(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::Class* __jsb_cc_Layers_class = nullptr; +se::Object* __jsb_cc_Layers_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Layers) + +static bool js_cc_Layers_makeMaskInclude_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< uint32_t > *arg1 = 0 ; + ccstd::vector< uint32_t > temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::Layers::makeMaskInclude((ccstd::vector< uint32_t > const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Layers_makeMaskInclude_static) + +static bool js_cc_Layers_makeMaskExclude_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< uint32_t > *arg1 = 0 ; + ccstd::vector< uint32_t > temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::Layers::makeMaskExclude((ccstd::vector< uint32_t > const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Layers_makeMaskExclude_static) + +bool js_register_cc_Layers(se::Object* obj) { + auto* cls = se::Class::create("Layers", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("makeMaskInclude", _SE(js_cc_Layers_makeMaskInclude_static)); + cls->defineStaticFunction("makeMaskExclude", _SE(js_cc_Layers_makeMaskExclude_static)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Layers_proto = cls->getProto(); + __jsb_cc_Layers_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_hasFlag__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + cc::Layers::LayerList arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasFlag(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasFlag(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_hasFlag__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_hasFlag__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_hasFlag) + +static bool js_cc_hasAnyFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + cc::Layers::LayerList arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAnyFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAnyFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_hasAnyFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_hasAnyFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_hasAnyFlags) + +static bool js_cc_hasAllFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + cc::Layers::LayerList arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAllFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAllFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_hasAllFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_hasAllFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_hasAllFlags) + +static bool js_cc_addFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList *arg1 = 0 ; + cc::Layers::LayerList arg2 ; + cc::Layers::LayerList temp1 ; + cc::Layers::LayerList result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Layers::LayerList)cc::addFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_addFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_addFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_addFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_addFlags) + +static bool js_cc_removeFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList *arg1 = 0 ; + cc::Layers::LayerList arg2 ; + cc::Layers::LayerList temp1 ; + cc::Layers::LayerList result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Layers::LayerList)cc::removeFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_removeFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_removeFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_removeFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_removeFlags) + +static bool js_cc_toNumber__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + std::underlying_type_t< cc::Layers::LayerList > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::toNumber(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; +} + +static bool js_cc_toNumber(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_toNumber__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_toNumber__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_toNumber) + +se::Class* __jsb_cc_Node_class = nullptr; +se::Object* __jsb_cc_Node_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Node) + +se::Class* __jsb_cc_Node_UserData_class = nullptr; +se::Object* __jsb_cc_Node_UserData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Node_UserData) + +static bool js_delete_cc_Node_UserData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Node_UserData) + +bool js_register_cc_Node_UserData(se::Object* obj) { + auto* cls = se::Class::create({"Node", "UserData"}, obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Node_UserData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Node_UserData_proto = cls->getProto(); + __jsb_cc_Node_UserData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_Node_instantiate_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + cc::Node *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], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Node *)cc::Node::instantiate(arg1,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_Node_instantiate_static) + +static bool js_cc_Node_setScene_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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::Node::setScene(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setScene_static) + +static bool js_cc_Node_resetHasChangedFlags_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::resetChangedFlags(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_resetHasChangedFlags_static) + +static bool js_cc_Node_clearNodeArray_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::clearNodeArray(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_clearNodeArray_static) + +static bool js_cc_Node__incSkewCompCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::_incSkewCompCount(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__incSkewCompCount_static) + +static bool js_cc_Node__decSkewCompCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::_decSkewCompCount(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__decSkewCompCount_static) + +static bool js_new_cc_Node__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Node *result; + result = (cc::Node *)new cc::Node(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Node__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::Node *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Node *)new cc::Node((ccstd::string const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Node(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Node__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Node__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Node"); + return false; +} +SE_BIND_CTOR(js_new_cc_Node, __jsb_cc_Node_class, js_delete_cc_Node) + +static bool js_delete_cc_Node(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Node) + +static bool js_cc_Node_onPostActivated(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->onPostActivated(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_onPostActivated) + +static bool js_cc_Node_setParent__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool arg3 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2,arg3); + + + return true; +} + +static bool js_cc_Node_setParent__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} + +static bool js_cc_Node_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Node_setParent__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Node_setParent__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setParent) + +static bool js_cc_Node_modifyParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->modifyParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_modifyParent) + +static bool js_cc_Node_getScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Scene *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(s); + if (nullptr == arg1) return true; + result = (cc::Scene *)((cc::Node const *)arg1)->getScene(); + + 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_Node_getScene) + +static bool js_cc_Node_walk__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node::WalkCallback *arg2 = 0 ; + cc::Node::WalkCallback temp2 ; + + arg1 = SE_THIS_OBJECT(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)->walk((cc::Node::WalkCallback const &)*arg2); + + + return true; +} + +static bool js_cc_Node_walk__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node::WalkCallback *arg2 = 0 ; + cc::Node::WalkCallback *arg3 = 0 ; + cc::Node::WalkCallback temp2 ; + cc::Node::WalkCallback temp3 ; + + arg1 = SE_THIS_OBJECT(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)->walk((cc::Node::WalkCallback const &)*arg2,(cc::Node::WalkCallback const &)*arg3); + + + return true; +} + +static bool js_cc_Node_walk(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_walk__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Node_walk__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_walk) + +static bool js_cc_Node_destroyAllChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyAllChildren(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_destroyAllChildren) + +static bool js_cc_Node__updateSiblingIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateSiblingIndex(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__updateSiblingIndex) + +static bool js_cc_Node_addChild(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addChild(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_addChild) + +static bool js_cc_Node_removeChild(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((cc::Node const *)arg1)->removeChild(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_removeChild) + +static bool js_cc_Node_removeFromParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeFromParent(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_removeFromParent) + +static bool js_cc_Node_removeAllChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeAllChildren(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_removeAllChildren) + +static bool js_cc_Node_isChildOf(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((cc::Node const *)arg1)->isChildOf(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_isChildOf) + +static bool js_cc_Node_setActive(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setActive(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setActive) + +static bool js_cc_Node_setSiblingIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSiblingIndex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setSiblingIndex) + +static bool js_cc_Node_isActive(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Node const *)arg1)->isActive(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_isActive) + +static bool js_cc_Node_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *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(s); + if (nullptr == arg1) return true; + result = (cc::Node *)((cc::Node const *)arg1)->getParent(); + + 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_Node_getParent) + +static bool js_cc_Node_getChildByUuid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Node *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(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::Node *)((cc::Node const *)arg1)->getChildByUuid((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_Node_getChildByUuid) + +static bool js_cc_Node_getChildByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Node *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(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::Node *)((cc::Node const *)arg1)->getChildByName((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_Node_getChildByName) + +static bool js_cc_Node_getChildByPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Node *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(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::Node *)((cc::Node const *)arg1)->getChildByPath((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_Node_getChildByPath) + +static bool js_cc_Node_getSiblingIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + index_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Node const *)arg1)->getSiblingIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_getSiblingIndex) + +static bool js_cc_Node_insertChild(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + index_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->insertChild(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_insertChild) + +static bool js_cc_Node_invalidateChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::TransformBit arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->invalidateChildren(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_invalidateChildren) + +static bool js_cc_Node_translate__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::NodeSpace arg3 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->translate((cc::Vec3 const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Node_translate__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->translate((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_translate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Node_translate__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Node_translate__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_translate) + +static bool js_cc_Node_lookAt__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->lookAt((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3); + + + return true; +} + +static bool js_cc_Node_lookAt__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->lookAt((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_lookAt(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Node_lookAt__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Node_lookAt__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_lookAt) + +static bool js_cc_Node_pauseSystemEvents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->pauseSystemEvents(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_pauseSystemEvents) + +static bool js_cc_Node_resumeSystemEvents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resumeSystemEvents(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_resumeSystemEvents) + +static bool js_cc_Node_getPathInHierarchy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Node const *)arg1)->getPathInHierarchy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Node_getPathInHierarchy) + +static bool js_cc_Node_setPositionInternal__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + bool arg4 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPositionInternal(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setPositionInternal__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + bool arg5 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPositionInternal(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Node_setPositionInternal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Node_setPositionInternal__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Node_setPositionInternal__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setPositionInternal) + +static bool js_cc_Node_setPositionForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPositionForJS(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setPositionForJS) + +static bool js_cc_Node_setRotationInternal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + bool arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRotationInternal(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setRotationInternal) + +static bool js_cc_Node_setRotationForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setRotationForJS(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setRotationForJS) + +static bool js_cc_Node_setEulerAngles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEulerAngles((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setEulerAngles) + +static bool js_cc_Node_setRotationFromEulerForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setRotationFromEulerForJS(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setRotationFromEulerForJS) + +static bool js_cc_Node_setScaleInternal__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + bool arg4 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setScaleInternal(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setScaleInternal__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + bool arg5 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setScaleInternal(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Node_setScaleInternal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Node_setScaleInternal__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Node_setScaleInternal__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setScaleInternal) + +static bool js_cc_Node_setScaleForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setScaleForJS(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setScaleForJS) + +static bool js_cc_Node_inverseTransformPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->inverseTransformPoint((cc::Vec3 const &)*arg2); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_Node_inverseTransformPoint) + +static bool js_cc_Node_setWorldPosition__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldPosition((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_setWorldPosition__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldPosition(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setWorldPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_setWorldPosition__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_Node_setWorldPosition__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setWorldPosition) + +static bool js_cc_Node_setWorldRotation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Quaternion *arg2 = 0 ; + cc::Quaternion temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldRotation((cc::Quaternion const &)*arg2); + + + return true; +} + +static bool js_cc_Node_setWorldRotation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldRotation(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Node_setWorldRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_setWorldRotation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Node_setWorldRotation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setWorldRotation) + +static bool js_cc_Node_setWorldScale__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldScale((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_setWorldScale__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldScale(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setWorldScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_setWorldScale__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_Node_setWorldScale__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setWorldScale) + +static bool js_cc_Node_setWorldRotationFromEuler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setWorldRotationFromEuler(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setWorldRotationFromEuler) + +static bool js_cc_Node_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_updateWorldTransform) + +static bool js_cc_Node_setForward(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setForward((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setForward) + +static bool js_cc_Node_isStatic(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Node const *)arg1)->isStatic(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_isStatic) + +static bool js_cc_Node_setStatic(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setStatic(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setStatic) + +static bool js_cc_Node_setLayer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setLayer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setLayer) + +static bool js_cc_Node_getLayer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Node const *)arg1)->getLayer(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_getLayer) + +static bool js_cc_Node__setChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::Node > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::Node > > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->_setChildren((ccstd::vector< cc::IntrusivePtr< cc::Node > > &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__setChildren) + +static bool js_cc_Node__getLocalOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::Node const *)arg1)->_getLocalOpacity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__getLocalOpacity) + +static bool js_cc_Node__getFinalOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::Node const *)arg1)->_getFinalOpacity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__getFinalOpacity) + +static bool js_cc_Node__setFinalOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_setFinalOpacity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__setFinalOpacity) + +static bool js_cc_Node__isColorDirty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Node const *)arg1)->_isColorDirty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__isColorDirty) + +static bool js_cc_Node__setColorDirty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_setColorDirty(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__setColorDirty) + +static bool js_cc_Node__onPreDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onPreDestroy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__onPreDestroy) + +static bool js_cc_Node__onPreDestroyBase(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onPreDestroyBase(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__onPreDestroyBase) + +static bool js_cc_Node__id_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_id, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__id_set) + +static bool js_cc_Node__id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_id, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_id, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__id_get) + +static bool js_cc_Node__parentInternal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__parentInternal_set) + +static bool js_cc_Node__parentInternal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__parentInternal_get) + +static bool js_cc_Node__mobility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_mobility, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__mobility_set) + +static bool js_cc_Node__mobility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_mobility, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_mobility, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__mobility_get) + +static bool js_cc_Node_uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_Node_uuid_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_Node_uuid_get) + +static bool js_cc_Node_angle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Node_angle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_angle_set) + +static bool js_cc_Node_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_Node_angle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_angle_get) + +static bool js_cc_Node_matrix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Node_matrix_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_matrix_set) + +static bool js_cc_Node_hasChangedFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Node_hasChangedFlags_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_hasChangedFlags_set) + +static bool js_cc_Node_hasChangedFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Node_hasChangedFlags_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_hasChangedFlags_get) + +static bool js_cc_Node_flagChangedVersion_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Node_flagChangedVersion_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_flagChangedVersion_get) + +static bool js_cc_Node__persistNode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Node__persistNode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__persistNode_set) + +static bool js_cc_Node__persistNode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Node__persistNode_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__persistNode_get) + +static bool js_cc_Node_mobility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::MobilityMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Node_mobility_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_mobility_set) + +static bool js_cc_Node_mobility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + cc::MobilityMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::MobilityMode)cc_Node_mobility_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_Node_mobility_get) + +static bool js_cc_Node_isSkipTransformUpdate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Node_isSkipTransformUpdate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_isSkipTransformUpdate_set) + +static bool js_cc_Node_isSkipTransformUpdate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Node_isSkipTransformUpdate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_isSkipTransformUpdate_get) + +bool js_register_cc_Node(se::Object* obj) { + auto* cls = se::Class::create("Node", obj, __jsb_cc_CCObject_proto, _SE(js_new_cc_Node)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_id", _SE(js_cc_Node__id_get), _SE(js_cc_Node__id_set)); + cls->defineProperty("_parentInternal", _SE(js_cc_Node__parentInternal_get), _SE(js_cc_Node__parentInternal_set)); + cls->defineProperty("_mobility", _SE(js_cc_Node__mobility_get), _SE(js_cc_Node__mobility_set)); + cls->defineProperty("uuid", _SE(js_cc_Node_uuid_get), nullptr); + cls->defineProperty("angle", _SE(js_cc_Node_angle_get), _SE(js_cc_Node_angle_set)); + cls->defineProperty("matrix", nullptr, _SE(js_cc_Node_matrix_set)); + cls->defineProperty("hasChangedFlags", _SE(js_cc_Node_hasChangedFlags_get), _SE(js_cc_Node_hasChangedFlags_set)); + cls->defineProperty("flagChangedVersion", _SE(js_cc_Node_flagChangedVersion_get), nullptr); + cls->defineProperty("_persistNode", _SE(js_cc_Node__persistNode_get), _SE(js_cc_Node__persistNode_set)); + cls->defineProperty("mobility", _SE(js_cc_Node_mobility_get), _SE(js_cc_Node_mobility_set)); + cls->defineProperty("isSkipTransformUpdate", _SE(js_cc_Node_isSkipTransformUpdate_get), _SE(js_cc_Node_isSkipTransformUpdate_set)); + + cls->defineFunction("onPostActivated", _SE(js_cc_Node_onPostActivated)); + cls->defineFunction("setParent", _SE(js_cc_Node_setParent)); + cls->defineFunction("modifyParent", _SE(js_cc_Node_modifyParent)); + cls->defineFunction("getScene", _SE(js_cc_Node_getScene)); + cls->defineFunction("walk", _SE(js_cc_Node_walk)); + cls->defineFunction("destroyAllChildren", _SE(js_cc_Node_destroyAllChildren)); + cls->defineFunction("_updateSiblingIndex", _SE(js_cc_Node__updateSiblingIndex)); + cls->defineFunction("addChild", _SE(js_cc_Node_addChild)); + cls->defineFunction("removeChild", _SE(js_cc_Node_removeChild)); + cls->defineFunction("removeFromParent", _SE(js_cc_Node_removeFromParent)); + cls->defineFunction("removeAllChildren", _SE(js_cc_Node_removeAllChildren)); + cls->defineFunction("isChildOf", _SE(js_cc_Node_isChildOf)); + cls->defineFunction("setActive", _SE(js_cc_Node_setActive)); + cls->defineFunction("setSiblingIndex", _SE(js_cc_Node_setSiblingIndex)); + cls->defineFunction("isActive", _SE(js_cc_Node_isActive)); + cls->defineFunction("getParent", _SE(js_cc_Node_getParent)); + cls->defineFunction("getChildByUuid", _SE(js_cc_Node_getChildByUuid)); + cls->defineFunction("getChildByName", _SE(js_cc_Node_getChildByName)); + cls->defineFunction("getChildByPath", _SE(js_cc_Node_getChildByPath)); + cls->defineFunction("getSiblingIndex", _SE(js_cc_Node_getSiblingIndex)); + cls->defineFunction("insertChild", _SE(js_cc_Node_insertChild)); + cls->defineFunction("invalidateChildren", _SE(js_cc_Node_invalidateChildren)); + cls->defineFunction("translate", _SE(js_cc_Node_translate)); + cls->defineFunction("lookAt", _SE(js_cc_Node_lookAt)); + cls->defineFunction("pauseSystemEvents", _SE(js_cc_Node_pauseSystemEvents)); + cls->defineFunction("resumeSystemEvents", _SE(js_cc_Node_resumeSystemEvents)); + cls->defineFunction("getPathInHierarchy", _SE(js_cc_Node_getPathInHierarchy)); + cls->defineFunction("setPositionInternal", _SE(js_cc_Node_setPositionInternal)); + cls->defineFunction("setPositionForJS", _SE(js_cc_Node_setPositionForJS)); + cls->defineFunction("setRotationInternal", _SE(js_cc_Node_setRotationInternal)); + cls->defineFunction("setRotationForJS", _SE(js_cc_Node_setRotationForJS)); + cls->defineFunction("setEulerAngles", _SE(js_cc_Node_setEulerAngles)); + cls->defineFunction("setRotationFromEulerForJS", _SE(js_cc_Node_setRotationFromEulerForJS)); + cls->defineFunction("setScaleInternal", _SE(js_cc_Node_setScaleInternal)); + cls->defineFunction("setScaleForJS", _SE(js_cc_Node_setScaleForJS)); + cls->defineFunction("inverseTransformPoint", _SE(js_cc_Node_inverseTransformPoint)); + cls->defineFunction("setWorldPosition", _SE(js_cc_Node_setWorldPosition)); + cls->defineFunction("setWorldRotation", _SE(js_cc_Node_setWorldRotation)); + cls->defineFunction("setWorldScale", _SE(js_cc_Node_setWorldScale)); + cls->defineFunction("setWorldRotationFromEuler", _SE(js_cc_Node_setWorldRotationFromEuler)); + cls->defineFunction("updateWorldTransform", _SE(js_cc_Node_updateWorldTransform)); + cls->defineFunction("setForward", _SE(js_cc_Node_setForward)); + cls->defineFunction("isStatic", _SE(js_cc_Node_isStatic)); + cls->defineFunction("setStatic", _SE(js_cc_Node_setStatic)); + cls->defineFunction("setLayer", _SE(js_cc_Node_setLayer)); + cls->defineFunction("getLayer", _SE(js_cc_Node_getLayer)); + cls->defineFunction("_setChildren", _SE(js_cc_Node__setChildren)); + cls->defineFunction("_getLocalOpacity", _SE(js_cc_Node__getLocalOpacity)); + cls->defineFunction("_getFinalOpacity", _SE(js_cc_Node__getFinalOpacity)); + cls->defineFunction("_setFinalOpacity", _SE(js_cc_Node__setFinalOpacity)); + cls->defineFunction("_isColorDirty", _SE(js_cc_Node__isColorDirty)); + cls->defineFunction("_setColorDirty", _SE(js_cc_Node__setColorDirty)); + cls->defineFunction("_onPreDestroy", _SE(js_cc_Node__onPreDestroy)); + cls->defineFunction("_onPreDestroyBase", _SE(js_cc_Node__onPreDestroyBase)); + + + cls->defineStaticFunction("instantiate", _SE(js_cc_Node_instantiate_static)); + cls->defineStaticFunction("setScene", _SE(js_cc_Node_setScene_static)); + cls->defineStaticFunction("resetHasChangedFlags", _SE(js_cc_Node_resetHasChangedFlags_static)); + cls->defineStaticFunction("clearNodeArray", _SE(js_cc_Node_clearNodeArray_static)); + cls->defineStaticFunction("_incSkewCompCount", _SE(js_cc_Node__incSkewCompCount_static)); + cls->defineStaticFunction("_decSkewCompCount", _SE(js_cc_Node__decSkewCompCount_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Node)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Node_proto = cls->getProto(); + __jsb_cc_Node_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Scene_class = nullptr; +se::Object* __jsb_cc_Scene_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Scene) + +static bool js_new_cc_Scene__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::Scene *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Scene *)new cc::Scene((ccstd::string const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Scene__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Scene *result; + result = (cc::Scene *)new cc::Scene(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Scene(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_cc_Scene__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_Scene__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Scene"); + return false; +} +SE_BIND_CTOR(js_new_cc_Scene, __jsb_cc_Scene_class, js_delete_cc_Scene) + +static bool js_delete_cc_Scene(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Scene) + +static bool js_cc_Scene_getRenderScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + cc::scene::RenderScene *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)((cc::Scene const *)arg1)->getRenderScene(); + + 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_Scene_getRenderScene) + +static bool js_cc_Scene_getSceneGlobals(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + cc::SceneGlobals *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(s); + if (nullptr == arg1) return true; + result = (cc::SceneGlobals *)((cc::Scene const *)arg1)->getSceneGlobals(); + + 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_Scene_getSceneGlobals) + +static bool js_cc_Scene_setSceneGlobals(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + cc::SceneGlobals *arg2 = (cc::SceneGlobals *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSceneGlobals(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Scene_setSceneGlobals) + +static bool js_cc_Scene__load(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->load(); + + + return true; +} +SE_BIND_FUNC(js_cc_Scene__load) + +static bool js_cc_Scene__activate__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} + +static bool js_cc_Scene__activate__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} + +static bool js_cc_Scene__activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Scene__activate__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Scene__activate__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Scene__activate) + +static bool js_cc_Scene_onBatchCreated(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->onBatchCreated(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Scene_onBatchCreated) + +static bool js_cc_Scene_autoReleaseAssets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Scene_autoReleaseAssets_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Scene_autoReleaseAssets_set) + +static bool js_cc_Scene_autoReleaseAssets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Scene_autoReleaseAssets_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Scene_autoReleaseAssets_get) + +bool js_register_cc_Scene(se::Object* obj) { + auto* cls = se::Class::create("Scene", obj, __jsb_cc_Node_proto, _SE(js_new_cc_Scene)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("autoReleaseAssets", _SE(js_cc_Scene_autoReleaseAssets_get), _SE(js_cc_Scene_autoReleaseAssets_set)); + + cls->defineFunction("getRenderScene", _SE(js_cc_Scene_getRenderScene)); + cls->defineFunction("getSceneGlobals", _SE(js_cc_Scene_getSceneGlobals)); + cls->defineFunction("setSceneGlobals", _SE(js_cc_Scene_setSceneGlobals)); + cls->defineFunction("_load", _SE(js_cc_Scene__load)); + cls->defineFunction("_activate", _SE(js_cc_Scene__activate)); + cls->defineFunction("onBatchCreated", _SE(js_cc_Scene_onBatchCreated)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Scene)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Scene_proto = cls->getProto(); + __jsb_cc_Scene_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SceneGlobals_class = nullptr; +se::Object* __jsb_cc_SceneGlobals_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SceneGlobals) + +static bool js_new_cc_SceneGlobals(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SceneGlobals *result; + result = (cc::SceneGlobals *)new cc::SceneGlobals(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SceneGlobals, __jsb_cc_SceneGlobals_class, js_delete_cc_SceneGlobals) + +static bool js_delete_cc_SceneGlobals(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SceneGlobals) + +static bool js_cc_SceneGlobals_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::Scene *arg2 = (cc::Scene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_activate) + +static bool js_cc_SceneGlobals_getAmbientInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::AmbientInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::AmbientInfo *)((cc::SceneGlobals const *)arg1)->getAmbientInfo(); + + 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_SceneGlobals_getAmbientInfo) + +static bool js_cc_SceneGlobals_getShadowsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::ShadowsInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::ShadowsInfo *)((cc::SceneGlobals const *)arg1)->getShadowsInfo(); + + 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_SceneGlobals_getShadowsInfo) + +static bool js_cc_SceneGlobals_getSkyboxInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkyboxInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::SkyboxInfo *)((cc::SceneGlobals const *)arg1)->getSkyboxInfo(); + + 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_SceneGlobals_getSkyboxInfo) + +static bool js_cc_SceneGlobals_getFogInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::FogInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::FogInfo *)((cc::SceneGlobals const *)arg1)->getFogInfo(); + + 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_SceneGlobals_getFogInfo) + +static bool js_cc_SceneGlobals_getOctreeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::OctreeInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::OctreeInfo *)((cc::SceneGlobals const *)arg1)->getOctreeInfo(); + + 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_SceneGlobals_getOctreeInfo) + +static bool js_cc_SceneGlobals_getLightProbeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::gi::LightProbeInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbeInfo *)((cc::SceneGlobals const *)arg1)->getLightProbeInfo(); + + 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_SceneGlobals_getLightProbeInfo) + +static bool js_cc_SceneGlobals_getSkinInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkinInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::SkinInfo *)((cc::SceneGlobals const *)arg1)->getSkinInfo(); + + 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_SceneGlobals_getSkinInfo) + +static bool js_cc_SceneGlobals_getPostSettingsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::PostSettingsInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::PostSettingsInfo *)((cc::SceneGlobals const *)arg1)->getPostSettingsInfo(); + + 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_SceneGlobals_getPostSettingsInfo) + +static bool js_cc_SceneGlobals_setAmbientInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::AmbientInfo *arg2 = (cc::scene::AmbientInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAmbientInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setAmbientInfo) + +static bool js_cc_SceneGlobals_setShadowsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::ShadowsInfo *arg2 = (cc::scene::ShadowsInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowsInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setShadowsInfo) + +static bool js_cc_SceneGlobals_setSkyboxInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkyboxInfo *arg2 = (cc::scene::SkyboxInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSkyboxInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setSkyboxInfo) + +static bool js_cc_SceneGlobals_setFogInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::FogInfo *arg2 = (cc::scene::FogInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFogInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setFogInfo) + +static bool js_cc_SceneGlobals_setOctreeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::OctreeInfo *arg2 = (cc::scene::OctreeInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOctreeInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setOctreeInfo) + +static bool js_cc_SceneGlobals_setLightProbeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::gi::LightProbeInfo *arg2 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLightProbeInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setLightProbeInfo) + +static bool js_cc_SceneGlobals_setSkinInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkinInfo *arg2 = (cc::scene::SkinInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSkinInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setSkinInfo) + +static bool js_cc_SceneGlobals_setPostSettingsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::PostSettingsInfo *arg2 = (cc::scene::PostSettingsInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPostSettingsInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setPostSettingsInfo) + +static bool js_cc_SceneGlobals_bakedWithStationaryMainLight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_SceneGlobals_bakedWithStationaryMainLight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_SceneGlobals_bakedWithStationaryMainLight_set) + +static bool js_cc_SceneGlobals_bakedWithStationaryMainLight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_SceneGlobals_bakedWithStationaryMainLight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_SceneGlobals_bakedWithStationaryMainLight_get) + +static bool js_cc_SceneGlobals_bakedWithHighpLightmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_SceneGlobals_bakedWithHighpLightmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_SceneGlobals_bakedWithHighpLightmap_set) + +static bool js_cc_SceneGlobals_bakedWithHighpLightmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_SceneGlobals_bakedWithHighpLightmap_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_SceneGlobals_bakedWithHighpLightmap_get) + +bool js_register_cc_SceneGlobals(se::Object* obj) { + auto* cls = se::Class::create("SceneGlobals", obj, nullptr, _SE(js_new_cc_SceneGlobals)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bakedWithStationaryMainLight", _SE(js_cc_SceneGlobals_bakedWithStationaryMainLight_get), _SE(js_cc_SceneGlobals_bakedWithStationaryMainLight_set)); + cls->defineProperty("bakedWithHighpLightmap", _SE(js_cc_SceneGlobals_bakedWithHighpLightmap_get), _SE(js_cc_SceneGlobals_bakedWithHighpLightmap_set)); + + cls->defineFunction("activate", _SE(js_cc_SceneGlobals_activate)); + cls->defineFunction("getAmbientInfo", _SE(js_cc_SceneGlobals_getAmbientInfo)); + cls->defineFunction("getShadowsInfo", _SE(js_cc_SceneGlobals_getShadowsInfo)); + cls->defineFunction("getSkyboxInfo", _SE(js_cc_SceneGlobals_getSkyboxInfo)); + cls->defineFunction("getFogInfo", _SE(js_cc_SceneGlobals_getFogInfo)); + cls->defineFunction("getOctreeInfo", _SE(js_cc_SceneGlobals_getOctreeInfo)); + cls->defineFunction("getLightProbeInfo", _SE(js_cc_SceneGlobals_getLightProbeInfo)); + cls->defineFunction("getSkinInfo", _SE(js_cc_SceneGlobals_getSkinInfo)); + cls->defineFunction("getPostSettingsInfo", _SE(js_cc_SceneGlobals_getPostSettingsInfo)); + cls->defineFunction("setAmbientInfo", _SE(js_cc_SceneGlobals_setAmbientInfo)); + cls->defineFunction("setShadowsInfo", _SE(js_cc_SceneGlobals_setShadowsInfo)); + cls->defineFunction("setSkyboxInfo", _SE(js_cc_SceneGlobals_setSkyboxInfo)); + cls->defineFunction("setFogInfo", _SE(js_cc_SceneGlobals_setFogInfo)); + cls->defineFunction("setOctreeInfo", _SE(js_cc_SceneGlobals_setOctreeInfo)); + cls->defineFunction("setLightProbeInfo", _SE(js_cc_SceneGlobals_setLightProbeInfo)); + cls->defineFunction("setSkinInfo", _SE(js_cc_SceneGlobals_setSkinInfo)); + cls->defineFunction("setPostSettingsInfo", _SE(js_cc_SceneGlobals_setPostSettingsInfo)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SceneGlobals)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SceneGlobals_proto = cls->getProto(); + __jsb_cc_SceneGlobals_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Root_class = nullptr; +se::Object* __jsb_cc_Root_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Root) + +static bool js_cc_Root_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::Root *)cc::Root::getInstance(); + + 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_Root_getInstance_static) + +static bool js_new_cc_Root(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::Root *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Root *)new cc::Root(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Root, __jsb_cc_Root_class, js_delete_cc_Root) + +static bool js_delete_cc_Root(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Root) + +static bool js_cc_Root__initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Swapchain *arg2 = (cc::gfx::Swapchain *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root__initialize) + +static bool js_cc_Root_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroy) + +static bool js_cc_Root_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_resize) + +static bool js_cc_Root_setRenderPipeline__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::pipeline::RenderPipeline *arg2 = (cc::pipeline::RenderPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(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)->setRenderPipeline(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Root_setRenderPipeline__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->setRenderPipeline(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Root_setRenderPipeline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Root_setRenderPipeline__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Root_setRenderPipeline__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Root_setRenderPipeline) + +static bool js_cc_Root_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_onGlobalPipelineStateChanged) + +static bool js_cc_Root_activeWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activeWindow(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_activeWindow) + +static bool js_cc_Root_resetCumulativeTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetCumulativeTime(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_resetCumulativeTime) + +static bool js_cc_Root_frameMove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + float arg2 ; + int32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->frameMove(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_frameMove) + +static bool js_cc_Root_createWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::IRenderWindowInfo *arg2 = 0 ; + cc::scene::IRenderWindowInfo temp2 ; + cc::scene::RenderWindow *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(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::scene::RenderWindow *)(arg1)->createWindow(*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_Root_createWindow) + +static bool js_cc_Root_destroyWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyWindow(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyWindow) + +static bool js_cc_Root_destroyWindows(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyWindows(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyWindows) + +static bool js_cc_Root_createSystemWindow_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = 0 ; + cc::ISystemWindowInfo temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::Root::createSystemWindow((cc::ISystemWindowInfo const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_createSystemWindow_static) + +static bool js_cc_Root_createScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::IRenderSceneInfo *arg2 = 0 ; + cc::scene::IRenderSceneInfo temp2 ; + cc::scene::RenderScene *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(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::scene::RenderScene *)(arg1)->createScene((cc::scene::IRenderSceneInfo 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_Root_createScene) + +static bool js_cc_Root_destroyScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyScene) + +static bool js_cc_Root_destroyScenes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyScenes(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyScenes) + +static bool js_cc_Root_destroyModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyModel) + +static bool js_cc_Root_destroyLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyLight) + +static bool js_cc_Root_createCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Camera *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Camera *)((cc::Root const *)arg1)->createCamera(); + + 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_Root_createCamera) + +static bool js_cc_Root_getBatcher2D(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::Batcher2d *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(s); + if (nullptr == arg1) return true; + result = (cc::Batcher2d *)((cc::Root const *)arg1)->getBatcher2D(); + + 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_Root_getBatcher2D) + +static bool js_cc_Root_createRenderWindowFromSystemWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t arg2 ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::scene::RenderWindow *)(arg1)->createRenderWindowFromSystemWindow(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_Root_createRenderWindowFromSystemWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::ISystemWindow *arg2 = (cc::ISystemWindow *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::RenderWindow *)(arg1)->createRenderWindowFromSystemWindow(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_Root_createRenderWindowFromSystemWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Root_createRenderWindowFromSystemWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Root_createRenderWindowFromSystemWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Root_createRenderWindowFromSystemWindow) + +static bool js_cc_Root_device_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root_device_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_device_set) + +static bool js_cc_Root_device_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)cc_Root_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_Root_device_get) + +static bool js_cc_Root__device_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root__device_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root__device_set) + +static bool js_cc_Root__device_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)cc_Root__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_Root__device_get) + +static bool js_cc_Root_mainWindow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_Root_mainWindow_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_Root_mainWindow_get) + +static bool js_cc_Root_curWindow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root_curWindow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_curWindow_set) + +static bool js_cc_Root_curWindow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_Root_curWindow_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_Root_curWindow_get) + +static bool js_cc_Root_tempWindow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root_tempWindow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_tempWindow_set) + +static bool js_cc_Root_tempWindow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_Root_tempWindow_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_Root_tempWindow_get) + +static bool js_cc_Root_windows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::RenderWindow > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::RenderWindow > > *) &cc_Root_windows_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_Root_windows_get) + +static bool js_cc_Root_scenes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::RenderScene > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::RenderScene > > *) &cc_Root_scenes_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_Root_scenes_get) + +static bool js_cc_Root_cumulativeTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_Root_cumulativeTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_cumulativeTime_get) + +static bool js_cc_Root_frameTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_Root_frameTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_frameTime_get) + +static bool js_cc_Root_frameCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Root_frameCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_frameCount_get) + +static bool js_cc_Root_fps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Root_fps_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_fps_get) + +static bool js_cc_Root_fixedFPS_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Root_fixedFPS_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_fixedFPS_set) + +static bool js_cc_Root_fixedFPS_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Root_fixedFPS_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_fixedFPS_get) + +static bool js_cc_Root_useDeferredPipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Root_useDeferredPipeline_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_useDeferredPipeline_get) + +static bool js_cc_Root_usesCustomPipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Root_usesCustomPipeline_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_usesCustomPipeline_get) + +static bool js_cc_Root_pipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::render::PipelineRuntime *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::PipelineRuntime *)cc_Root_pipeline_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_Root_pipeline_get) + +static bool js_cc_Root_customPipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::render::Pipeline *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::Pipeline *)cc_Root_customPipeline_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_Root_customPipeline_get) + +static bool js_cc_Root_cameraList_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + ccstd::vector< cc::scene::Camera * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::scene::Camera * > *) &cc_Root_cameraList_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_Root_cameraList_get) + +static bool js_cc_Root_debugView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::pipeline::DebugView *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::DebugView *)cc_Root_debugView_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_Root_debugView_get) + +bool js_register_cc_Root(se::Object* obj) { + auto* cls = se::Class::create("Root", obj, nullptr, _SE(js_new_cc_Root)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("device", _SE(js_cc_Root_device_get), _SE(js_cc_Root_device_set)); + cls->defineProperty("_device", _SE(js_cc_Root__device_get), _SE(js_cc_Root__device_set)); + cls->defineProperty("mainWindow", _SE(js_cc_Root_mainWindow_get), nullptr); + cls->defineProperty("curWindow", _SE(js_cc_Root_curWindow_get), _SE(js_cc_Root_curWindow_set)); + cls->defineProperty("tempWindow", _SE(js_cc_Root_tempWindow_get), _SE(js_cc_Root_tempWindow_set)); + cls->defineProperty("windows", _SE(js_cc_Root_windows_get), nullptr); + cls->defineProperty("scenes", _SE(js_cc_Root_scenes_get), nullptr); + cls->defineProperty("cumulativeTime", _SE(js_cc_Root_cumulativeTime_get), nullptr); + cls->defineProperty("frameTime", _SE(js_cc_Root_frameTime_get), nullptr); + cls->defineProperty("frameCount", _SE(js_cc_Root_frameCount_get), nullptr); + cls->defineProperty("fps", _SE(js_cc_Root_fps_get), nullptr); + cls->defineProperty("fixedFPS", _SE(js_cc_Root_fixedFPS_get), _SE(js_cc_Root_fixedFPS_set)); + cls->defineProperty("useDeferredPipeline", _SE(js_cc_Root_useDeferredPipeline_get), nullptr); + cls->defineProperty("usesCustomPipeline", _SE(js_cc_Root_usesCustomPipeline_get), nullptr); + cls->defineProperty("pipeline", _SE(js_cc_Root_pipeline_get), nullptr); + cls->defineProperty("customPipeline", _SE(js_cc_Root_customPipeline_get), nullptr); + cls->defineProperty("cameraList", _SE(js_cc_Root_cameraList_get), nullptr); + cls->defineProperty("debugView", _SE(js_cc_Root_debugView_get), nullptr); + + cls->defineFunction("_initialize", _SE(js_cc_Root__initialize)); + cls->defineFunction("destroy", _SE(js_cc_Root_destroy)); + cls->defineFunction("resize", _SE(js_cc_Root_resize)); + cls->defineFunction("setRenderPipeline", _SE(js_cc_Root_setRenderPipeline)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_Root_onGlobalPipelineStateChanged)); + cls->defineFunction("activeWindow", _SE(js_cc_Root_activeWindow)); + cls->defineFunction("resetCumulativeTime", _SE(js_cc_Root_resetCumulativeTime)); + cls->defineFunction("frameMove", _SE(js_cc_Root_frameMove)); + cls->defineFunction("createWindow", _SE(js_cc_Root_createWindow)); + cls->defineFunction("destroyWindow", _SE(js_cc_Root_destroyWindow)); + cls->defineFunction("destroyWindows", _SE(js_cc_Root_destroyWindows)); + cls->defineFunction("createScene", _SE(js_cc_Root_createScene)); + cls->defineFunction("destroyScene", _SE(js_cc_Root_destroyScene)); + cls->defineFunction("destroyScenes", _SE(js_cc_Root_destroyScenes)); + cls->defineFunction("destroyModel", _SE(js_cc_Root_destroyModel)); + cls->defineFunction("destroyLight", _SE(js_cc_Root_destroyLight)); + cls->defineFunction("createCamera", _SE(js_cc_Root_createCamera)); + cls->defineFunction("getBatcher2D", _SE(js_cc_Root_getBatcher2D)); + cls->defineFunction("createRenderWindowFromSystemWindow", _SE(js_cc_Root_createRenderWindowFromSystemWindow)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_Root_getInstance_static)); + cls->defineStaticFunction("createSystemWindow", _SE(js_cc_Root_createSystemWindow_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Root)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Root_proto = cls->getProto(); + __jsb_cc_Root_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IMacroPatch_class = nullptr; +se::Object* __jsb_cc_scene_IMacroPatch_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IMacroPatch) + +static bool js_cc_scene_IMacroPatch_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IMacroPatch_name_set) + +static bool js_cc_scene_IMacroPatch_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IMacroPatch_name_get) + +static bool js_cc_scene_IMacroPatch_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IMacroPatch_value_set) + +static bool js_cc_scene_IMacroPatch_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->value, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IMacroPatch_value_get) + +static bool js_new_cc_scene_IMacroPatch__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::scene::IMacroPatch *result; + result = (cc::scene::IMacroPatch *)new cc::scene::IMacroPatch(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_IMacroPatch__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string *arg1 = 0 ; + cc::MacroValue *arg2 = 0 ; + ccstd::string temp1 ; + cc::MacroValue temp2 ; + cc::scene::IMacroPatch *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::scene::IMacroPatch *)new cc::scene::IMacroPatch((ccstd::string const &)*arg1,(cc::MacroValue const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_IMacroPatch(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_scene_IMacroPatch__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_scene_IMacroPatch__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of IMacroPatch"); + return false; +} +SE_BIND_CTOR(js_new_cc_scene_IMacroPatch, __jsb_cc_scene_IMacroPatch_class, js_delete_cc_scene_IMacroPatch) + +static bool js_cc_scene_IMacroPatch_compare_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IMacroPatch *arg1 = 0 ; + cc::scene::IMacroPatch *arg2 = 0 ; + cc::scene::IMacroPatch temp1 ; + cc::scene::IMacroPatch temp2 ; + bool result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)cc::scene::IMacroPatch::compare((cc::scene::IMacroPatch const &)*arg1,(cc::scene::IMacroPatch const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_IMacroPatch_compare_static) + +static bool js_delete_cc_scene_IMacroPatch(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IMacroPatch) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IMacroPatch * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IMacroPatch(se::Object* obj) { + auto* cls = se::Class::create("IMacroPatch", obj, nullptr, _SE(js_new_cc_scene_IMacroPatch)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_IMacroPatch_name_get), _SE(js_cc_scene_IMacroPatch_name_set)); + cls->defineProperty("value", _SE(js_cc_scene_IMacroPatch_value_get), _SE(js_cc_scene_IMacroPatch_value_set)); + + + + cls->defineStaticFunction("compare", _SE(js_cc_scene_IMacroPatch_compare_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IMacroPatch)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IMacroPatch_proto = cls->getProto(); + __jsb_cc_scene_IMacroPatch_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Light_class = nullptr; +se::Object* __jsb_cc_scene_Light_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Light) + +static bool js_new_cc_scene_Light(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Light *result; + result = (cc::scene::Light *)new cc::scene::Light(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Light, __jsb_cc_scene_Light_class, js_delete_cc_scene_Light) + +static bool js_delete_cc_scene_Light(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Light) + +static bool js_cc_scene_Light_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_attachToScene) + +static bool js_cc_scene_Light_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_detachFromScene) + +static bool js_cc_scene_Light_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_destroy) + +static bool js_cc_scene_Light_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_initialize) + +static bool js_cc_scene_Light_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_update) + +static bool js_cc_scene_Light_nt2lm_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::scene::Light::nt2lm(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_nt2lm_static) + +static bool js_cc_scene_Light_colorTemperatureToRGB_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::scene::Light::colorTemperatureToRGB(arg1); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_colorTemperatureToRGB_static) + +static bool js_cc_scene_Light_baked_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_baked_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_baked_set) + +static bool js_cc_scene_Light_baked_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Light_baked_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_baked_get) + +static bool js_cc_scene_Light_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Light_color_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_color_set) + +static bool js_cc_scene_Light_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Light_color_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_scene_Light_color_get) + +static bool js_cc_scene_Light_useColorTemperature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_useColorTemperature_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_useColorTemperature_set) + +static bool js_cc_scene_Light_useColorTemperature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Light_useColorTemperature_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_useColorTemperature_get) + +static bool js_cc_scene_Light_colorTemperature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_colorTemperature_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_colorTemperature_set) + +static bool js_cc_scene_Light_colorTemperature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Light_colorTemperature_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_colorTemperature_get) + +static bool js_cc_scene_Light_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_node_set) + +static bool js_cc_scene_Light_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Light_node_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_scene_Light_node_get) + +static bool js_cc_scene_Light_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::LightType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Light_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_type_set) + +static bool js_cc_scene_Light_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::LightType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::LightType)cc_scene_Light_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_type_get) + +static bool js_cc_scene_Light_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Light_name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_name_set) + +static bool js_cc_scene_Light_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_Light_name_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_scene_Light_name_get) + +static bool js_cc_scene_Light_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_Light_scene_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_scene_Light_scene_get) + +static bool js_cc_scene_Light_visibility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Light_visibility_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_visibility_set) + +static bool js_cc_scene_Light_visibility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Light_visibility_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_visibility_get) + +static bool js_cc_scene_Light_colorTemperatureRGB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Light_colorTemperatureRGB_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_colorTemperatureRGB_set) + +static bool js_cc_scene_Light_colorTemperatureRGB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Light_colorTemperatureRGB_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_scene_Light_colorTemperatureRGB_get) + +bool js_register_cc_scene_Light(se::Object* obj) { + auto* cls = se::Class::create("Light", obj, nullptr, _SE(js_new_cc_scene_Light)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("baked", _SE(js_cc_scene_Light_baked_get), _SE(js_cc_scene_Light_baked_set)); + cls->defineProperty("color", _SE(js_cc_scene_Light_color_get), _SE(js_cc_scene_Light_color_set)); + cls->defineProperty("useColorTemperature", _SE(js_cc_scene_Light_useColorTemperature_get), _SE(js_cc_scene_Light_useColorTemperature_set)); + cls->defineProperty("colorTemperature", _SE(js_cc_scene_Light_colorTemperature_get), _SE(js_cc_scene_Light_colorTemperature_set)); + cls->defineProperty("node", _SE(js_cc_scene_Light_node_get), _SE(js_cc_scene_Light_node_set)); + cls->defineProperty("type", _SE(js_cc_scene_Light_type_get), _SE(js_cc_scene_Light_type_set)); + cls->defineProperty("name", _SE(js_cc_scene_Light_name_get), _SE(js_cc_scene_Light_name_set)); + cls->defineProperty("scene", _SE(js_cc_scene_Light_scene_get), nullptr); + cls->defineProperty("visibility", _SE(js_cc_scene_Light_visibility_get), _SE(js_cc_scene_Light_visibility_set)); + cls->defineProperty("colorTemperatureRGB", _SE(js_cc_scene_Light_colorTemperatureRGB_get), _SE(js_cc_scene_Light_colorTemperatureRGB_set)); + + cls->defineFunction("attachToScene", _SE(js_cc_scene_Light_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_Light_detachFromScene)); + cls->defineFunction("destroy", _SE(js_cc_scene_Light_destroy)); + cls->defineFunction("initialize", _SE(js_cc_scene_Light_initialize)); + cls->defineFunction("update", _SE(js_cc_scene_Light_update)); + + + cls->defineStaticFunction("nt2lm", _SE(js_cc_scene_Light_nt2lm_static)); + cls->defineStaticFunction("colorTemperatureToRGB", _SE(js_cc_scene_Light_colorTemperatureToRGB_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Light)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Light_proto = cls->getProto(); + __jsb_cc_scene_Light_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_LODData_class = nullptr; +se::Object* __jsb_cc_scene_LODData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_LODData) + +static bool js_cc_scene_LODData_addModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODData_addModel) + +static bool js_cc_scene_LODData_clearModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODData_clearModels) + +static bool js_cc_scene_LODData_eraseModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->eraseModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODData_eraseModel) + +static bool js_cc_scene_LODData_screenUsagePercentage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODData_screenUsagePercentage_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODData_screenUsagePercentage_set) + +static bool js_cc_scene_LODData_screenUsagePercentage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_LODData_screenUsagePercentage_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODData_screenUsagePercentage_get) + +static bool js_cc_scene_LODData_models_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *) &cc_scene_LODData_models_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_scene_LODData_models_get) + +static bool js_new_cc_scene_LODData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::LODData *result; + result = (cc::scene::LODData *)new cc::scene::LODData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_LODData, __jsb_cc_scene_LODData_class, js_delete_cc_scene_LODData) + +static bool js_delete_cc_scene_LODData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_LODData) + +bool js_register_cc_scene_LODData(se::Object* obj) { + auto* cls = se::Class::create("LODData", obj, nullptr, _SE(js_new_cc_scene_LODData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("screenUsagePercentage", _SE(js_cc_scene_LODData_screenUsagePercentage_get), _SE(js_cc_scene_LODData_screenUsagePercentage_set)); + cls->defineProperty("models", _SE(js_cc_scene_LODData_models_get), nullptr); + + cls->defineFunction("addModel", _SE(js_cc_scene_LODData_addModel)); + cls->defineFunction("clearModels", _SE(js_cc_scene_LODData_clearModels)); + cls->defineFunction("eraseModel", _SE(js_cc_scene_LODData_eraseModel)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_LODData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_LODData_proto = cls->getProto(); + __jsb_cc_scene_LODData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_LODGroup_class = nullptr; +se::Object* __jsb_cc_scene_LODGroup_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_LODGroup) + +static bool js_new_cc_scene_LODGroup(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::LODGroup *result; + result = (cc::scene::LODGroup *)new cc::scene::LODGroup(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_LODGroup, __jsb_cc_scene_LODGroup_class, js_delete_cc_scene_LODGroup) + +static bool js_delete_cc_scene_LODGroup(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_LODGroup) + +static bool js_cc_scene_LODGroup_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_attachToScene) + +static bool js_cc_scene_LODGroup_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_detachFromScene) + +static bool js_cc_scene_LODGroup_getVisibleLODLevel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + int8_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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((cc::scene::LODGroup const *)arg1)->getVisibleLODLevel((cc::scene::Camera const *)arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_getVisibleLODLevel) + +static bool js_cc_scene_LODGroup_getLockedLODLevels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + ccstd::vector< uint8_t > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< uint8_t > *) &((cc::scene::LODGroup const *)arg1)->getLockedLODLevels(); + + 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_scene_LODGroup_getLockedLODLevels) + +static bool js_cc_scene_LODGroup_lockLODLevels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + ccstd::vector< int > *arg2 = 0 ; + ccstd::vector< int > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->lockLODLevels(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_lockLODLevels) + +static bool js_cc_scene_LODGroup_isLockLevelChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::LODGroup const *)arg1)->isLockLevelChanged(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_isLockLevelChanged) + +static bool js_cc_scene_LODGroup_resetLockChangeFlag(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetLockChangeFlag(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_resetLockChangeFlag) + +static bool js_cc_scene_LODGroup_clearLODs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearLODs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_clearLODs) + +static bool js_cc_scene_LODGroup_insertLOD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t arg2 ; + cc::scene::LODData *arg3 = (cc::scene::LODData *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->insertLOD(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_insertLOD) + +static bool js_cc_scene_LODGroup_updateLOD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t arg2 ; + cc::scene::LODData *arg3 = (cc::scene::LODData *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLOD(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_updateLOD) + +static bool js_cc_scene_LODGroup_eraseLOD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->eraseLOD(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_eraseLOD) + +static bool js_cc_scene_LODGroup_lodCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_LODGroup_lodCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODGroup_lodCount_get) + +static bool js_cc_scene_LODGroup_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODGroup_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_enabled_set) + +static bool js_cc_scene_LODGroup_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_LODGroup_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODGroup_enabled_get) + +static bool js_cc_scene_LODGroup_localBoundaryCenter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_LODGroup_localBoundaryCenter_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_localBoundaryCenter_set) + +static bool js_cc_scene_LODGroup_localBoundaryCenter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_LODGroup_localBoundaryCenter_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_scene_LODGroup_localBoundaryCenter_get) + +static bool js_cc_scene_LODGroup_objectSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODGroup_objectSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_objectSize_set) + +static bool js_cc_scene_LODGroup_objectSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_LODGroup_objectSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODGroup_objectSize_get) + +static bool js_cc_scene_LODGroup_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODGroup_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_node_set) + +static bool js_cc_scene_LODGroup_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_LODGroup_node_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_scene_LODGroup_node_get) + +static bool js_cc_scene_LODGroup_lodDataArray_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::LODData > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::LODData > > *) &cc_scene_LODGroup_lodDataArray_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_scene_LODGroup_lodDataArray_get) + +static bool js_cc_scene_LODGroup_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_LODGroup_scene_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_scene_LODGroup_scene_get) + +bool js_register_cc_scene_LODGroup(se::Object* obj) { + auto* cls = se::Class::create("LODGroup", obj, nullptr, _SE(js_new_cc_scene_LODGroup)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("lodCount", _SE(js_cc_scene_LODGroup_lodCount_get), nullptr); + cls->defineProperty("enabled", _SE(js_cc_scene_LODGroup_enabled_get), _SE(js_cc_scene_LODGroup_enabled_set)); + cls->defineProperty("localBoundaryCenter", _SE(js_cc_scene_LODGroup_localBoundaryCenter_get), _SE(js_cc_scene_LODGroup_localBoundaryCenter_set)); + cls->defineProperty("objectSize", _SE(js_cc_scene_LODGroup_objectSize_get), _SE(js_cc_scene_LODGroup_objectSize_set)); + cls->defineProperty("node", _SE(js_cc_scene_LODGroup_node_get), _SE(js_cc_scene_LODGroup_node_set)); + cls->defineProperty("lodDataArray", _SE(js_cc_scene_LODGroup_lodDataArray_get), nullptr); + cls->defineProperty("scene", _SE(js_cc_scene_LODGroup_scene_get), nullptr); + + cls->defineFunction("attachToScene", _SE(js_cc_scene_LODGroup_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_LODGroup_detachFromScene)); + cls->defineFunction("getVisibleLODLevel", _SE(js_cc_scene_LODGroup_getVisibleLODLevel)); + cls->defineFunction("getLockedLODLevels", _SE(js_cc_scene_LODGroup_getLockedLODLevels)); + cls->defineFunction("lockLODLevels", _SE(js_cc_scene_LODGroup_lockLODLevels)); + cls->defineFunction("isLockLevelChanged", _SE(js_cc_scene_LODGroup_isLockLevelChanged)); + cls->defineFunction("resetLockChangeFlag", _SE(js_cc_scene_LODGroup_resetLockChangeFlag)); + cls->defineFunction("clearLODs", _SE(js_cc_scene_LODGroup_clearLODs)); + cls->defineFunction("insertLOD", _SE(js_cc_scene_LODGroup_insertLOD)); + cls->defineFunction("updateLOD", _SE(js_cc_scene_LODGroup_updateLOD)); + cls->defineFunction("eraseLOD", _SE(js_cc_scene_LODGroup_eraseLOD)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_LODGroup)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_LODGroup_proto = cls->getProto(); + __jsb_cc_scene_LODGroup_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Fog_class = nullptr; +se::Object* __jsb_cc_scene_Fog_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Fog) + +static bool js_new_cc_scene_Fog(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Fog *result; + result = (cc::scene::Fog *)new cc::scene::Fog(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Fog, __jsb_cc_scene_Fog_class, js_delete_cc_scene_Fog) + +static bool js_delete_cc_scene_Fog(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Fog) + +static bool js_cc_scene_Fog_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::scene::FogInfo *arg2 = 0 ; + cc::scene::FogInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::FogInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Fog_initialize) + +static bool js_cc_scene_Fog_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Fog_activate) + +static bool js_cc_scene_Fog_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_enabled_set) + +static bool js_cc_scene_Fog_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Fog_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_enabled_get) + +static bool js_cc_scene_Fog_accurate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_accurate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_accurate_set) + +static bool js_cc_scene_Fog_accurate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Fog_accurate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_accurate_get) + +static bool js_cc_scene_Fog_fogColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Fog_fogColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogColor_set) + +static bool js_cc_scene_Fog_fogColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_Fog_fogColor_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_scene_Fog_fogColor_get) + +static bool js_cc_scene_Fog_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::scene::FogType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Fog_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_type_set) + +static bool js_cc_scene_Fog_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::scene::FogType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::FogType)cc_scene_Fog_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_type_get) + +static bool js_cc_scene_Fog_fogDensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogDensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogDensity_set) + +static bool js_cc_scene_Fog_fogDensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogDensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogDensity_get) + +static bool js_cc_scene_Fog_fogStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogStart_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogStart_set) + +static bool js_cc_scene_Fog_fogStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogStart_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogStart_get) + +static bool js_cc_scene_Fog_fogEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogEnd_set) + +static bool js_cc_scene_Fog_fogEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogEnd_get) + +static bool js_cc_scene_Fog_fogAtten_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogAtten_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogAtten_set) + +static bool js_cc_scene_Fog_fogAtten_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogAtten_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogAtten_get) + +static bool js_cc_scene_Fog_fogTop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogTop_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogTop_set) + +static bool js_cc_scene_Fog_fogTop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogTop_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogTop_get) + +static bool js_cc_scene_Fog_fogRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogRange_set) + +static bool js_cc_scene_Fog_fogRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogRange_get) + +static bool js_cc_scene_Fog_colorArray_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_Fog_colorArray_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_scene_Fog_colorArray_get) + +bool js_register_cc_scene_Fog(se::Object* obj) { + auto* cls = se::Class::create("Fog", obj, nullptr, _SE(js_new_cc_scene_Fog)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enabled", _SE(js_cc_scene_Fog_enabled_get), _SE(js_cc_scene_Fog_enabled_set)); + cls->defineProperty("accurate", _SE(js_cc_scene_Fog_accurate_get), _SE(js_cc_scene_Fog_accurate_set)); + cls->defineProperty("fogColor", _SE(js_cc_scene_Fog_fogColor_get), _SE(js_cc_scene_Fog_fogColor_set)); + cls->defineProperty("type", _SE(js_cc_scene_Fog_type_get), _SE(js_cc_scene_Fog_type_set)); + cls->defineProperty("fogDensity", _SE(js_cc_scene_Fog_fogDensity_get), _SE(js_cc_scene_Fog_fogDensity_set)); + cls->defineProperty("fogStart", _SE(js_cc_scene_Fog_fogStart_get), _SE(js_cc_scene_Fog_fogStart_set)); + cls->defineProperty("fogEnd", _SE(js_cc_scene_Fog_fogEnd_get), _SE(js_cc_scene_Fog_fogEnd_set)); + cls->defineProperty("fogAtten", _SE(js_cc_scene_Fog_fogAtten_get), _SE(js_cc_scene_Fog_fogAtten_set)); + cls->defineProperty("fogTop", _SE(js_cc_scene_Fog_fogTop_get), _SE(js_cc_scene_Fog_fogTop_set)); + cls->defineProperty("fogRange", _SE(js_cc_scene_Fog_fogRange_get), _SE(js_cc_scene_Fog_fogRange_set)); + cls->defineProperty("colorArray", _SE(js_cc_scene_Fog_colorArray_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Fog_initialize)); + cls->defineFunction("activate", _SE(js_cc_scene_Fog_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Fog)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Fog_proto = cls->getProto(); + __jsb_cc_scene_Fog_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_FogInfo_class = nullptr; +se::Object* __jsb_cc_scene_FogInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_FogInfo) + +static bool js_new_cc_scene_FogInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::FogInfo *result; + result = (cc::scene::FogInfo *)new cc::scene::FogInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_FogInfo, __jsb_cc_scene_FogInfo_class, js_delete_cc_scene_FogInfo) + +static bool js_delete_cc_scene_FogInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_FogInfo) + +static bool js_cc_scene_FogInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::scene::Fog *arg2 = (cc::scene::Fog *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_FogInfo_activate) + +static bool js_cc_scene_FogInfo__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__type_set) + +static bool js_cc_scene_FogInfo__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__type_get) + +static bool js_cc_scene_FogInfo__fogColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogColor_set) + +static bool js_cc_scene_FogInfo__fogColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_fogColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogColor_get) + +static bool js_cc_scene_FogInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_isEnabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__enabled_set) + +static bool js_cc_scene_FogInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_isEnabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__enabled_get) + +static bool js_cc_scene_FogInfo__fogDensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogDensity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogDensity_set) + +static bool js_cc_scene_FogInfo__fogDensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogDensity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogDensity_get) + +static bool js_cc_scene_FogInfo__fogStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogStart, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogStart_set) + +static bool js_cc_scene_FogInfo__fogStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogStart, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogStart_get) + +static bool js_cc_scene_FogInfo__fogEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogEnd, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogEnd_set) + +static bool js_cc_scene_FogInfo__fogEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogEnd, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogEnd_get) + +static bool js_cc_scene_FogInfo__fogAtten_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogAtten, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogAtten_set) + +static bool js_cc_scene_FogInfo__fogAtten_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogAtten, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogAtten_get) + +static bool js_cc_scene_FogInfo__fogTop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogTop, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogTop_set) + +static bool js_cc_scene_FogInfo__fogTop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogTop, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogTop_get) + +static bool js_cc_scene_FogInfo__fogRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogRange, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogRange_set) + +static bool js_cc_scene_FogInfo__fogRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogRange, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogRange_get) + +static bool js_cc_scene_FogInfo__accurate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_accurate); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__accurate_set) + +static bool js_cc_scene_FogInfo__accurate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_accurate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__accurate_get) + +static bool js_cc_scene_FogInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__resource_set) + +static bool js_cc_scene_FogInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__resource_get) + +static bool js_cc_scene_FogInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::scene::FogType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_FogInfo_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_type_set) + +static bool js_cc_scene_FogInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::scene::FogType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::FogType)cc_scene_FogInfo_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_type_get) + +static bool js_cc_scene_FogInfo_fogColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_FogInfo_fogColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogColor_set) + +static bool js_cc_scene_FogInfo_fogColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_FogInfo_fogColor_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_scene_FogInfo_fogColor_get) + +static bool js_cc_scene_FogInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_enabled_set) + +static bool js_cc_scene_FogInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_FogInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_enabled_get) + +static bool js_cc_scene_FogInfo_accurate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_accurate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_accurate_set) + +static bool js_cc_scene_FogInfo_accurate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_FogInfo_accurate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_accurate_get) + +static bool js_cc_scene_FogInfo_fogDensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogDensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogDensity_set) + +static bool js_cc_scene_FogInfo_fogDensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogDensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogDensity_get) + +static bool js_cc_scene_FogInfo_fogStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogStart_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogStart_set) + +static bool js_cc_scene_FogInfo_fogStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogStart_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogStart_get) + +static bool js_cc_scene_FogInfo_fogEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogEnd_set) + +static bool js_cc_scene_FogInfo_fogEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogEnd_get) + +static bool js_cc_scene_FogInfo_fogAtten_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogAtten_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogAtten_set) + +static bool js_cc_scene_FogInfo_fogAtten_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogAtten_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogAtten_get) + +static bool js_cc_scene_FogInfo_fogTop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogTop_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogTop_set) + +static bool js_cc_scene_FogInfo_fogTop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogTop_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogTop_get) + +static bool js_cc_scene_FogInfo_fogRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogRange_set) + +static bool js_cc_scene_FogInfo_fogRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogRange_get) + +bool js_register_cc_scene_FogInfo(se::Object* obj) { + auto* cls = se::Class::create("FogInfo", obj, nullptr, _SE(js_new_cc_scene_FogInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_type", _SE(js_cc_scene_FogInfo__type_get), _SE(js_cc_scene_FogInfo__type_set)); + cls->defineProperty("_fogColor", _SE(js_cc_scene_FogInfo__fogColor_get), _SE(js_cc_scene_FogInfo__fogColor_set)); + cls->defineProperty("_enabled", _SE(js_cc_scene_FogInfo__enabled_get), _SE(js_cc_scene_FogInfo__enabled_set)); + cls->defineProperty("_fogDensity", _SE(js_cc_scene_FogInfo__fogDensity_get), _SE(js_cc_scene_FogInfo__fogDensity_set)); + cls->defineProperty("_fogStart", _SE(js_cc_scene_FogInfo__fogStart_get), _SE(js_cc_scene_FogInfo__fogStart_set)); + cls->defineProperty("_fogEnd", _SE(js_cc_scene_FogInfo__fogEnd_get), _SE(js_cc_scene_FogInfo__fogEnd_set)); + cls->defineProperty("_fogAtten", _SE(js_cc_scene_FogInfo__fogAtten_get), _SE(js_cc_scene_FogInfo__fogAtten_set)); + cls->defineProperty("_fogTop", _SE(js_cc_scene_FogInfo__fogTop_get), _SE(js_cc_scene_FogInfo__fogTop_set)); + cls->defineProperty("_fogRange", _SE(js_cc_scene_FogInfo__fogRange_get), _SE(js_cc_scene_FogInfo__fogRange_set)); + cls->defineProperty("_accurate", _SE(js_cc_scene_FogInfo__accurate_get), _SE(js_cc_scene_FogInfo__accurate_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_FogInfo__resource_get), _SE(js_cc_scene_FogInfo__resource_set)); + cls->defineProperty("type", _SE(js_cc_scene_FogInfo_type_get), _SE(js_cc_scene_FogInfo_type_set)); + cls->defineProperty("fogColor", _SE(js_cc_scene_FogInfo_fogColor_get), _SE(js_cc_scene_FogInfo_fogColor_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_FogInfo_enabled_get), _SE(js_cc_scene_FogInfo_enabled_set)); + cls->defineProperty("accurate", _SE(js_cc_scene_FogInfo_accurate_get), _SE(js_cc_scene_FogInfo_accurate_set)); + cls->defineProperty("fogDensity", _SE(js_cc_scene_FogInfo_fogDensity_get), _SE(js_cc_scene_FogInfo_fogDensity_set)); + cls->defineProperty("fogStart", _SE(js_cc_scene_FogInfo_fogStart_get), _SE(js_cc_scene_FogInfo_fogStart_set)); + cls->defineProperty("fogEnd", _SE(js_cc_scene_FogInfo_fogEnd_get), _SE(js_cc_scene_FogInfo_fogEnd_set)); + cls->defineProperty("fogAtten", _SE(js_cc_scene_FogInfo_fogAtten_get), _SE(js_cc_scene_FogInfo_fogAtten_set)); + cls->defineProperty("fogTop", _SE(js_cc_scene_FogInfo_fogTop_get), _SE(js_cc_scene_FogInfo_fogTop_set)); + cls->defineProperty("fogRange", _SE(js_cc_scene_FogInfo_fogRange_get), _SE(js_cc_scene_FogInfo_fogRange_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_FogInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_FogInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_FogInfo_proto = cls->getProto(); + __jsb_cc_scene_FogInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_ShadowsInfo_class = nullptr; +se::Object* __jsb_cc_scene_ShadowsInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_ShadowsInfo) + +static bool js_new_cc_scene_ShadowsInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::ShadowsInfo *result; + result = (cc::scene::ShadowsInfo *)new cc::scene::ShadowsInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_ShadowsInfo, __jsb_cc_scene_ShadowsInfo_class, js_delete_cc_scene_ShadowsInfo) + +static bool js_delete_cc_scene_ShadowsInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_ShadowsInfo) + +static bool js_cc_scene_ShadowsInfo_setPlaneFromNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPlaneFromNode((cc::Node const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ShadowsInfo_setPlaneFromNode) + +static bool js_cc_scene_ShadowsInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::scene::Shadows *arg2 = (cc::scene::Shadows *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ShadowsInfo_activate) + +static bool js_cc_scene_ShadowsInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__enabled_set) + +static bool js_cc_scene_ShadowsInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__enabled_get) + +static bool js_cc_scene_ShadowsInfo__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__type_set) + +static bool js_cc_scene_ShadowsInfo__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__type_get) + +static bool js_cc_scene_ShadowsInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__resource_set) + +static bool js_cc_scene_ShadowsInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__resource_get) + +static bool js_cc_scene_ShadowsInfo__maxReceived_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_maxReceived, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__maxReceived_set) + +static bool js_cc_scene_ShadowsInfo__maxReceived_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_maxReceived, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__maxReceived_get) + +static bool js_cc_scene_ShadowsInfo__distance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_distance, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__distance_set) + +static bool js_cc_scene_ShadowsInfo__distance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_distance, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__distance_get) + +static bool js_cc_scene_ShadowsInfo__planeBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_planeBias, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__planeBias_set) + +static bool js_cc_scene_ShadowsInfo__planeBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_planeBias, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__planeBias_get) + +static bool js_cc_scene_ShadowsInfo__size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__size_set) + +static bool js_cc_scene_ShadowsInfo__size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_size, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_size, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__size_get) + +static bool js_cc_scene_ShadowsInfo__normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__normal_set) + +static bool js_cc_scene_ShadowsInfo__normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__normal_get) + +static bool js_cc_scene_ShadowsInfo__shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_shadowColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__shadowColor_set) + +static bool js_cc_scene_ShadowsInfo__shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_shadowColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_shadowColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__shadowColor_get) + +static bool js_cc_scene_ShadowsInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_enabled_set) + +static bool js_cc_scene_ShadowsInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_ShadowsInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_enabled_get) + +static bool js_cc_scene_ShadowsInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::scene::ShadowType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ShadowsInfo_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_type_set) + +static bool js_cc_scene_ShadowsInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::scene::ShadowType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ShadowType)cc_scene_ShadowsInfo_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_type_get) + +static bool js_cc_scene_ShadowsInfo_shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ShadowsInfo_shadowColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_shadowColor_set) + +static bool js_cc_scene_ShadowsInfo_shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_ShadowsInfo_shadowColor_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_scene_ShadowsInfo_shadowColor_get) + +static bool js_cc_scene_ShadowsInfo_planeDirection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ShadowsInfo_planeDirection_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_planeDirection_set) + +static bool js_cc_scene_ShadowsInfo_planeDirection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_ShadowsInfo_planeDirection_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_scene_ShadowsInfo_planeDirection_get) + +static bool js_cc_scene_ShadowsInfo_planeHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_planeHeight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_planeHeight_set) + +static bool js_cc_scene_ShadowsInfo_planeHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_ShadowsInfo_planeHeight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_planeHeight_get) + +static bool js_cc_scene_ShadowsInfo_planeBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_planeBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_planeBias_set) + +static bool js_cc_scene_ShadowsInfo_planeBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_ShadowsInfo_planeBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_planeBias_get) + +static bool js_cc_scene_ShadowsInfo_maxReceived_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ShadowsInfo_maxReceived_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_maxReceived_set) + +static bool js_cc_scene_ShadowsInfo_maxReceived_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ShadowsInfo_maxReceived_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_maxReceived_get) + +static bool js_cc_scene_ShadowsInfo_shadowMapSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_shadowMapSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_shadowMapSize_set) + +static bool js_cc_scene_ShadowsInfo_shadowMapSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_ShadowsInfo_shadowMapSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_shadowMapSize_get) + +bool js_register_cc_scene_ShadowsInfo(se::Object* obj) { + auto* cls = se::Class::create("ShadowsInfo", obj, nullptr, _SE(js_new_cc_scene_ShadowsInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_enabled", _SE(js_cc_scene_ShadowsInfo__enabled_get), _SE(js_cc_scene_ShadowsInfo__enabled_set)); + cls->defineProperty("_type", _SE(js_cc_scene_ShadowsInfo__type_get), _SE(js_cc_scene_ShadowsInfo__type_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_ShadowsInfo__resource_get), _SE(js_cc_scene_ShadowsInfo__resource_set)); + cls->defineProperty("_maxReceived", _SE(js_cc_scene_ShadowsInfo__maxReceived_get), _SE(js_cc_scene_ShadowsInfo__maxReceived_set)); + cls->defineProperty("_distance", _SE(js_cc_scene_ShadowsInfo__distance_get), _SE(js_cc_scene_ShadowsInfo__distance_set)); + cls->defineProperty("_planeBias", _SE(js_cc_scene_ShadowsInfo__planeBias_get), _SE(js_cc_scene_ShadowsInfo__planeBias_set)); + cls->defineProperty("_size", _SE(js_cc_scene_ShadowsInfo__size_get), _SE(js_cc_scene_ShadowsInfo__size_set)); + cls->defineProperty("_normal", _SE(js_cc_scene_ShadowsInfo__normal_get), _SE(js_cc_scene_ShadowsInfo__normal_set)); + cls->defineProperty("_shadowColor", _SE(js_cc_scene_ShadowsInfo__shadowColor_get), _SE(js_cc_scene_ShadowsInfo__shadowColor_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_ShadowsInfo_enabled_get), _SE(js_cc_scene_ShadowsInfo_enabled_set)); + cls->defineProperty("type", _SE(js_cc_scene_ShadowsInfo_type_get), _SE(js_cc_scene_ShadowsInfo_type_set)); + cls->defineProperty("shadowColor", _SE(js_cc_scene_ShadowsInfo_shadowColor_get), _SE(js_cc_scene_ShadowsInfo_shadowColor_set)); + cls->defineProperty("planeDirection", _SE(js_cc_scene_ShadowsInfo_planeDirection_get), _SE(js_cc_scene_ShadowsInfo_planeDirection_set)); + cls->defineProperty("planeHeight", _SE(js_cc_scene_ShadowsInfo_planeHeight_get), _SE(js_cc_scene_ShadowsInfo_planeHeight_set)); + cls->defineProperty("planeBias", _SE(js_cc_scene_ShadowsInfo_planeBias_get), _SE(js_cc_scene_ShadowsInfo_planeBias_set)); + cls->defineProperty("maxReceived", _SE(js_cc_scene_ShadowsInfo_maxReceived_get), _SE(js_cc_scene_ShadowsInfo_maxReceived_set)); + cls->defineProperty("shadowMapSize", _SE(js_cc_scene_ShadowsInfo_shadowMapSize_get), _SE(js_cc_scene_ShadowsInfo_shadowMapSize_set)); + + cls->defineFunction("setPlaneFromNode", _SE(js_cc_scene_ShadowsInfo_setPlaneFromNode)); + cls->defineFunction("activate", _SE(js_cc_scene_ShadowsInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_ShadowsInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_ShadowsInfo_proto = cls->getProto(); + __jsb_cc_scene_ShadowsInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Shadows_class = nullptr; +se::Object* __jsb_cc_scene_Shadows_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Shadows) + +static bool js_new_cc_scene_Shadows(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Shadows *result; + result = (cc::scene::Shadows *)new cc::scene::Shadows(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Shadows, __jsb_cc_scene_Shadows_class, js_delete_cc_scene_Shadows) + +static bool js_delete_cc_scene_Shadows(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Shadows) + +static bool js_cc_scene_Shadows_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::scene::ShadowsInfo *arg2 = 0 ; + cc::scene::ShadowsInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::ShadowsInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_initialize) + +static bool js_cc_scene_Shadows_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_destroy) + +static bool js_cc_scene_Shadows_getPlanarShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + cc::gfx::Shader *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(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::gfx::Shader *)(arg1)->getPlanarShader((ccstd::vector< cc::scene::IMacroPatch > 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_scene_Shadows_getPlanarShader) + +static bool js_cc_scene_Shadows_getPlanarInstanceShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + cc::gfx::Shader *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(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::gfx::Shader *)(arg1)->getPlanarInstanceShader((ccstd::vector< cc::scene::IMacroPatch > 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_scene_Shadows_getPlanarInstanceShader) + +static bool js_cc_scene_Shadows_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_activate) + +static bool js_cc_scene_Shadows_getShadowColor4f(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + ccstd::array< float,4 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::array< float,4 > *) &((cc::scene::Shadows const *)arg1)->getShadowColor4f(); + + 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_scene_Shadows_getShadowColor4f) + +static bool js_cc_scene_Shadows_setShadowMapSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowMapSize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_setShadowMapSize) + +static bool js_cc_scene_Shadows_getShadowMapSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::Shadows const *)arg1)->getShadowMapSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_getShadowMapSize) + +static bool js_cc_scene_Shadows_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_enabled_set) + +static bool js_cc_scene_Shadows_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Shadows_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_enabled_get) + +static bool js_cc_scene_Shadows_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::scene::ShadowType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Shadows_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_type_set) + +static bool js_cc_scene_Shadows_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::scene::ShadowType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ShadowType)cc_scene_Shadows_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_type_get) + +static bool js_cc_scene_Shadows_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Shadows_normal_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_normal_set) + +static bool js_cc_scene_Shadows_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Shadows_normal_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_scene_Shadows_normal_get) + +static bool js_cc_scene_Shadows_distance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_distance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_distance_set) + +static bool js_cc_scene_Shadows_distance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Shadows_distance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_distance_get) + +static bool js_cc_scene_Shadows_planeBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_planeBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_planeBias_set) + +static bool js_cc_scene_Shadows_planeBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Shadows_planeBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_planeBias_get) + +static bool js_cc_scene_Shadows_shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Shadows_shadowColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_shadowColor_set) + +static bool js_cc_scene_Shadows_shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_Shadows_shadowColor_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_scene_Shadows_shadowColor_get) + +static bool js_cc_scene_Shadows_maxReceived_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Shadows_maxReceived_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_maxReceived_set) + +static bool js_cc_scene_Shadows_maxReceived_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Shadows_maxReceived_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_maxReceived_get) + +static bool js_cc_scene_Shadows_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec2 *arg2 = 0 ; + cc::Vec2 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Shadows_size_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_size_set) + +static bool js_cc_scene_Shadows_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec2 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec2 *) &cc_scene_Shadows_size_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_scene_Shadows_size_get) + +static bool js_cc_scene_Shadows_shadowMapDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_shadowMapDirty_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_shadowMapDirty_set) + +static bool js_cc_scene_Shadows_shadowMapDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Shadows_shadowMapDirty_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_shadowMapDirty_get) + +static bool js_cc_scene_Shadows_matLight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Mat4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &cc_scene_Shadows_matLight_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_scene_Shadows_matLight_get) + +static bool js_cc_scene_Shadows_material_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_scene_Shadows_material_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_scene_Shadows_material_get) + +static bool js_cc_scene_Shadows_instancingMaterial_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_scene_Shadows_instancingMaterial_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_scene_Shadows_instancingMaterial_get) + +bool js_register_cc_scene_Shadows(se::Object* obj) { + auto* cls = se::Class::create("Shadows", obj, nullptr, _SE(js_new_cc_scene_Shadows)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enabled", _SE(js_cc_scene_Shadows_enabled_get), _SE(js_cc_scene_Shadows_enabled_set)); + cls->defineProperty("type", _SE(js_cc_scene_Shadows_type_get), _SE(js_cc_scene_Shadows_type_set)); + cls->defineProperty("normal", _SE(js_cc_scene_Shadows_normal_get), _SE(js_cc_scene_Shadows_normal_set)); + cls->defineProperty("distance", _SE(js_cc_scene_Shadows_distance_get), _SE(js_cc_scene_Shadows_distance_set)); + cls->defineProperty("planeBias", _SE(js_cc_scene_Shadows_planeBias_get), _SE(js_cc_scene_Shadows_planeBias_set)); + cls->defineProperty("shadowColor", _SE(js_cc_scene_Shadows_shadowColor_get), _SE(js_cc_scene_Shadows_shadowColor_set)); + cls->defineProperty("maxReceived", _SE(js_cc_scene_Shadows_maxReceived_get), _SE(js_cc_scene_Shadows_maxReceived_set)); + cls->defineProperty("size", _SE(js_cc_scene_Shadows_size_get), _SE(js_cc_scene_Shadows_size_set)); + cls->defineProperty("shadowMapDirty", _SE(js_cc_scene_Shadows_shadowMapDirty_get), _SE(js_cc_scene_Shadows_shadowMapDirty_set)); + cls->defineProperty("matLight", _SE(js_cc_scene_Shadows_matLight_get), nullptr); + cls->defineProperty("material", _SE(js_cc_scene_Shadows_material_get), nullptr); + cls->defineProperty("instancingMaterial", _SE(js_cc_scene_Shadows_instancingMaterial_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Shadows_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_Shadows_destroy)); + cls->defineFunction("getPlanarShader", _SE(js_cc_scene_Shadows_getPlanarShader)); + cls->defineFunction("getPlanarInstanceShader", _SE(js_cc_scene_Shadows_getPlanarInstanceShader)); + cls->defineFunction("activate", _SE(js_cc_scene_Shadows_activate)); + cls->defineFunction("getShadowColor4f", _SE(js_cc_scene_Shadows_getShadowColor4f)); + cls->defineFunction("setShadowMapSize", _SE(js_cc_scene_Shadows_setShadowMapSize)); + cls->defineFunction("getShadowMapSize", _SE(js_cc_scene_Shadows_getShadowMapSize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Shadows)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Shadows_proto = cls->getProto(); + __jsb_cc_scene_Shadows_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SkyboxInfo_class = nullptr; +se::Object* __jsb_cc_scene_SkyboxInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SkyboxInfo) + +static bool js_new_cc_scene_SkyboxInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SkyboxInfo *result; + result = (cc::scene::SkyboxInfo *)new cc::scene::SkyboxInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SkyboxInfo, __jsb_cc_scene_SkyboxInfo_class, js_delete_cc_scene_SkyboxInfo) + +static bool js_delete_cc_scene_SkyboxInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SkyboxInfo) + +static bool js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + ccstd::string *arg2 = 0 ; + cc::MaterialPropertyVariant *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((cc::scene::SkyboxInfo const *)arg1)->setMaterialProperty((ccstd::string const &)*arg2,(cc::MaterialPropertyVariant const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + ccstd::string *arg2 = 0 ; + cc::MaterialPropertyVariant *arg3 = 0 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant temp3 ; + + arg1 = SE_THIS_OBJECT(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; + + ((cc::scene::SkyboxInfo const *)arg1)->setMaterialProperty((ccstd::string const &)*arg2,(cc::MaterialPropertyVariant const &)*arg3); + + + return true; +} + +static bool js_cc_scene_SkyboxInfo_setMaterialProperty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_SkyboxInfo_setMaterialProperty) + +static bool js_cc_scene_SkyboxInfo_updateEnvMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateEnvMap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkyboxInfo_updateEnvMap) + +static bool js_cc_scene_SkyboxInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::scene::Skybox *arg2 = (cc::scene::Skybox *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkyboxInfo_activate) + +static bool js_cc_scene_SkyboxInfo__envmapHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_envmapHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envmapHDR_set) + +static bool js_cc_scene_SkyboxInfo__envmapHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_envmapHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_envmapHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__envmapHDR_get) + +static bool js_cc_scene_SkyboxInfo__envmapLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_envmapLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envmapLDR_set) + +static bool js_cc_scene_SkyboxInfo__envmapLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_envmapLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_envmapLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__envmapLDR_get) + +static bool js_cc_scene_SkyboxInfo__diffuseMapHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_diffuseMapHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__diffuseMapHDR_set) + +static bool js_cc_scene_SkyboxInfo__diffuseMapHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_diffuseMapHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_diffuseMapHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__diffuseMapHDR_get) + +static bool js_cc_scene_SkyboxInfo__diffuseMapLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_diffuseMapLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__diffuseMapLDR_set) + +static bool js_cc_scene_SkyboxInfo__diffuseMapLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_diffuseMapLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_diffuseMapLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__diffuseMapLDR_get) + +static bool js_cc_scene_SkyboxInfo__reflectionHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reflectionHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__reflectionHDR_set) + +static bool js_cc_scene_SkyboxInfo__reflectionHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reflectionHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_reflectionHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__reflectionHDR_get) + +static bool js_cc_scene_SkyboxInfo__reflectionLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reflectionLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__reflectionLDR_set) + +static bool js_cc_scene_SkyboxInfo__reflectionLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reflectionLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_reflectionLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__reflectionLDR_get) + +static bool js_cc_scene_SkyboxInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__enabled_set) + +static bool js_cc_scene_SkyboxInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__enabled_get) + +static bool js_cc_scene_SkyboxInfo__useHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_useHDR); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__useHDR_set) + +static bool js_cc_scene_SkyboxInfo__useHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_useHDR, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__useHDR_get) + +static bool js_cc_scene_SkyboxInfo__envLightingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_envLightingType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envLightingType_set) + +static bool js_cc_scene_SkyboxInfo__envLightingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_envLightingType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_envLightingType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__envLightingType_get) + +static bool js_cc_scene_SkyboxInfo__editableMaterial_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_editableMaterial, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__editableMaterial_set) + +static bool js_cc_scene_SkyboxInfo__editableMaterial_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_editableMaterial, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_editableMaterial, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__editableMaterial_get) + +static bool js_cc_scene_SkyboxInfo__rotationAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_rotationAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__rotationAngle_set) + +static bool js_cc_scene_SkyboxInfo__rotationAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_rotationAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__rotationAngle_get) + +static bool js_cc_scene_SkyboxInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__resource_set) + +static bool js_cc_scene_SkyboxInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__resource_get) + +static bool js_cc_scene_SkyboxInfo__envmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo__envmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envmap_set) + +static bool js_cc_scene_SkyboxInfo__envmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo__envmap_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_scene_SkyboxInfo__envmap_get) + +static bool js_cc_scene_SkyboxInfo_applyDiffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_applyDiffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_applyDiffuseMap_set) + +static bool js_cc_scene_SkyboxInfo_applyDiffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_applyDiffuseMap_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_applyDiffuseMap_get) + +static bool js_cc_scene_SkyboxInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_enabled_set) + +static bool js_cc_scene_SkyboxInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_enabled_get) + +static bool js_cc_scene_SkyboxInfo_useIBL_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_useIBL_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_useIBL_set) + +static bool js_cc_scene_SkyboxInfo_useIBL_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_useIBL_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_useIBL_get) + +static bool js_cc_scene_SkyboxInfo_useHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_useHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_useHDR_set) + +static bool js_cc_scene_SkyboxInfo_useHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_useHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_useHDR_get) + +static bool js_cc_scene_SkyboxInfo_envmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_envmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_envmap_set) + +static bool js_cc_scene_SkyboxInfo_envmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo_envmap_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_scene_SkyboxInfo_envmap_get) + +static bool js_cc_scene_SkyboxInfo_diffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_diffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_diffuseMap_set) + +static bool js_cc_scene_SkyboxInfo_diffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo_diffuseMap_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_scene_SkyboxInfo_diffuseMap_get) + +static bool js_cc_scene_SkyboxInfo_reflectionMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_reflectionMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_reflectionMap_set) + +static bool js_cc_scene_SkyboxInfo_reflectionMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo_reflectionMap_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_scene_SkyboxInfo_reflectionMap_get) + +static bool js_cc_scene_SkyboxInfo_skyboxMaterial_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_skyboxMaterial_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_skyboxMaterial_set) + +static bool js_cc_scene_SkyboxInfo_skyboxMaterial_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_scene_SkyboxInfo_skyboxMaterial_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_scene_SkyboxInfo_skyboxMaterial_get) + +static bool js_cc_scene_SkyboxInfo_rotationAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_rotationAngle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_rotationAngle_set) + +static bool js_cc_scene_SkyboxInfo_rotationAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SkyboxInfo_rotationAngle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_rotationAngle_get) + +static bool js_cc_scene_SkyboxInfo_envLightingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::scene::EnvironmentLightingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_SkyboxInfo_envLightingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_envLightingType_set) + +static bool js_cc_scene_SkyboxInfo_envLightingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::scene::EnvironmentLightingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::EnvironmentLightingType)cc_scene_SkyboxInfo_envLightingType_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_scene_SkyboxInfo_envLightingType_get) + +bool js_register_cc_scene_SkyboxInfo(se::Object* obj) { + auto* cls = se::Class::create("SkyboxInfo", obj, nullptr, _SE(js_new_cc_scene_SkyboxInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_envmapHDR", _SE(js_cc_scene_SkyboxInfo__envmapHDR_get), _SE(js_cc_scene_SkyboxInfo__envmapHDR_set)); + cls->defineProperty("_envmapLDR", _SE(js_cc_scene_SkyboxInfo__envmapLDR_get), _SE(js_cc_scene_SkyboxInfo__envmapLDR_set)); + cls->defineProperty("_diffuseMapHDR", _SE(js_cc_scene_SkyboxInfo__diffuseMapHDR_get), _SE(js_cc_scene_SkyboxInfo__diffuseMapHDR_set)); + cls->defineProperty("_diffuseMapLDR", _SE(js_cc_scene_SkyboxInfo__diffuseMapLDR_get), _SE(js_cc_scene_SkyboxInfo__diffuseMapLDR_set)); + cls->defineProperty("_reflectionHDR", _SE(js_cc_scene_SkyboxInfo__reflectionHDR_get), _SE(js_cc_scene_SkyboxInfo__reflectionHDR_set)); + cls->defineProperty("_reflectionLDR", _SE(js_cc_scene_SkyboxInfo__reflectionLDR_get), _SE(js_cc_scene_SkyboxInfo__reflectionLDR_set)); + cls->defineProperty("_enabled", _SE(js_cc_scene_SkyboxInfo__enabled_get), _SE(js_cc_scene_SkyboxInfo__enabled_set)); + cls->defineProperty("_useHDR", _SE(js_cc_scene_SkyboxInfo__useHDR_get), _SE(js_cc_scene_SkyboxInfo__useHDR_set)); + cls->defineProperty("_envLightingType", _SE(js_cc_scene_SkyboxInfo__envLightingType_get), _SE(js_cc_scene_SkyboxInfo__envLightingType_set)); + cls->defineProperty("_editableMaterial", _SE(js_cc_scene_SkyboxInfo__editableMaterial_get), _SE(js_cc_scene_SkyboxInfo__editableMaterial_set)); + cls->defineProperty("_rotationAngle", _SE(js_cc_scene_SkyboxInfo__rotationAngle_get), _SE(js_cc_scene_SkyboxInfo__rotationAngle_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_SkyboxInfo__resource_get), _SE(js_cc_scene_SkyboxInfo__resource_set)); + cls->defineProperty("_envmap", _SE(js_cc_scene_SkyboxInfo__envmap_get), _SE(js_cc_scene_SkyboxInfo__envmap_set)); + cls->defineProperty("applyDiffuseMap", _SE(js_cc_scene_SkyboxInfo_applyDiffuseMap_get), _SE(js_cc_scene_SkyboxInfo_applyDiffuseMap_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_SkyboxInfo_enabled_get), _SE(js_cc_scene_SkyboxInfo_enabled_set)); + cls->defineProperty("useIBL", _SE(js_cc_scene_SkyboxInfo_useIBL_get), _SE(js_cc_scene_SkyboxInfo_useIBL_set)); + cls->defineProperty("useHDR", _SE(js_cc_scene_SkyboxInfo_useHDR_get), _SE(js_cc_scene_SkyboxInfo_useHDR_set)); + cls->defineProperty("envmap", _SE(js_cc_scene_SkyboxInfo_envmap_get), _SE(js_cc_scene_SkyboxInfo_envmap_set)); + cls->defineProperty("diffuseMap", _SE(js_cc_scene_SkyboxInfo_diffuseMap_get), _SE(js_cc_scene_SkyboxInfo_diffuseMap_set)); + cls->defineProperty("reflectionMap", _SE(js_cc_scene_SkyboxInfo_reflectionMap_get), _SE(js_cc_scene_SkyboxInfo_reflectionMap_set)); + cls->defineProperty("skyboxMaterial", _SE(js_cc_scene_SkyboxInfo_skyboxMaterial_get), _SE(js_cc_scene_SkyboxInfo_skyboxMaterial_set)); + cls->defineProperty("rotationAngle", _SE(js_cc_scene_SkyboxInfo_rotationAngle_get), _SE(js_cc_scene_SkyboxInfo_rotationAngle_set)); + cls->defineProperty("envLightingType", _SE(js_cc_scene_SkyboxInfo_envLightingType_get), _SE(js_cc_scene_SkyboxInfo_envLightingType_set)); + + cls->defineFunction("setMaterialProperty", _SE(js_cc_scene_SkyboxInfo_setMaterialProperty)); + cls->defineFunction("updateEnvMap", _SE(js_cc_scene_SkyboxInfo_updateEnvMap)); + cls->defineFunction("activate", _SE(js_cc_scene_SkyboxInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SkyboxInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SkyboxInfo_proto = cls->getProto(); + __jsb_cc_scene_SkyboxInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Skybox_class = nullptr; +se::Object* __jsb_cc_scene_Skybox_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Skybox) + +static bool js_new_cc_scene_Skybox(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Skybox *result; + result = (cc::scene::Skybox *)new cc::scene::Skybox(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Skybox, __jsb_cc_scene_Skybox_class, js_delete_cc_scene_Skybox) + +static bool js_delete_cc_scene_Skybox(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Skybox) + +static bool js_cc_scene_Skybox_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::scene::SkyboxInfo *arg2 = 0 ; + cc::scene::SkyboxInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::SkyboxInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_initialize) + +static bool js_cc_scene_Skybox_setEnvMaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + cc::TextureCube *arg3 = (cc::TextureCube *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEnvMaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setEnvMaps) + +static bool js_cc_scene_Skybox_setDiffuseMaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + cc::TextureCube *arg3 = (cc::TextureCube *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDiffuseMaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setDiffuseMaps) + +static bool js_cc_scene_Skybox_setReflectionMaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + cc::TextureCube *arg3 = (cc::TextureCube *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setReflectionMaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setReflectionMaps) + +static bool js_cc_scene_Skybox_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_activate) + +static bool js_cc_scene_Skybox_isUsingConvolutionMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Skybox const *)arg1)->isUsingConvolutionMap(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_isUsingConvolutionMap) + +static bool js_cc_scene_Skybox_setSkyboxMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSkyboxMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setSkyboxMaterial) + +static bool js_cc_scene_Skybox_getSkyboxMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::Material *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(s); + if (nullptr == arg1) return true; + result = (cc::Material *)((cc::scene::Skybox const *)arg1)->getSkyboxMaterial(); + + 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_scene_Skybox_getSkyboxMaterial) + +static bool js_cc_scene_Skybox_setRotationAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRotationAngle(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setRotationAngle) + +static bool js_cc_scene_Skybox_getRotationAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::Skybox const *)arg1)->getRotationAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_getRotationAngle) + +static bool js_cc_scene_Skybox_getReflectionMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *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(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)((cc::scene::Skybox const *)arg1)->getReflectionMap(); + + 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_scene_Skybox_getReflectionMap) + +static bool js_cc_scene_Skybox_model_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_scene_Skybox_model_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_scene_Skybox_model_get) + +static bool js_cc_scene_Skybox_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_enabled_set) + +static bool js_cc_scene_Skybox_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_enabled_get) + +static bool js_cc_scene_Skybox_useHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_useHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_useHDR_set) + +static bool js_cc_scene_Skybox_useHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_useHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_useHDR_get) + +static bool js_cc_scene_Skybox_useIBL_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_useIBL_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_useIBL_set) + +static bool js_cc_scene_Skybox_useIBL_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_useIBL_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_useIBL_get) + +static bool js_cc_scene_Skybox_useDiffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_useDiffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_useDiffuseMap_set) + +static bool js_cc_scene_Skybox_useDiffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_useDiffuseMap_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_useDiffuseMap_get) + +static bool js_cc_scene_Skybox_isRGBE_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_isRGBE_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_isRGBE_get) + +static bool js_cc_scene_Skybox_envmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_envmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_envmap_set) + +static bool js_cc_scene_Skybox_envmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_Skybox_envmap_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_scene_Skybox_envmap_get) + +static bool js_cc_scene_Skybox_diffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_diffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_diffuseMap_set) + +static bool js_cc_scene_Skybox_diffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_Skybox_diffuseMap_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_scene_Skybox_diffuseMap_get) + +bool js_register_cc_scene_Skybox(se::Object* obj) { + auto* cls = se::Class::create("Skybox", obj, nullptr, _SE(js_new_cc_scene_Skybox)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("model", _SE(js_cc_scene_Skybox_model_get), nullptr); + cls->defineProperty("enabled", _SE(js_cc_scene_Skybox_enabled_get), _SE(js_cc_scene_Skybox_enabled_set)); + cls->defineProperty("useHDR", _SE(js_cc_scene_Skybox_useHDR_get), _SE(js_cc_scene_Skybox_useHDR_set)); + cls->defineProperty("useIBL", _SE(js_cc_scene_Skybox_useIBL_get), _SE(js_cc_scene_Skybox_useIBL_set)); + cls->defineProperty("useDiffuseMap", _SE(js_cc_scene_Skybox_useDiffuseMap_get), _SE(js_cc_scene_Skybox_useDiffuseMap_set)); + cls->defineProperty("isRGBE", _SE(js_cc_scene_Skybox_isRGBE_get), nullptr); + cls->defineProperty("envmap", _SE(js_cc_scene_Skybox_envmap_get), _SE(js_cc_scene_Skybox_envmap_set)); + cls->defineProperty("diffuseMap", _SE(js_cc_scene_Skybox_diffuseMap_get), _SE(js_cc_scene_Skybox_diffuseMap_set)); + + cls->defineFunction("initialize", _SE(js_cc_scene_Skybox_initialize)); + cls->defineFunction("setEnvMaps", _SE(js_cc_scene_Skybox_setEnvMaps)); + cls->defineFunction("setDiffuseMaps", _SE(js_cc_scene_Skybox_setDiffuseMaps)); + cls->defineFunction("setReflectionMaps", _SE(js_cc_scene_Skybox_setReflectionMaps)); + cls->defineFunction("activate", _SE(js_cc_scene_Skybox_activate)); + cls->defineFunction("isUsingConvolutionMap", _SE(js_cc_scene_Skybox_isUsingConvolutionMap)); + cls->defineFunction("setSkyboxMaterial", _SE(js_cc_scene_Skybox_setSkyboxMaterial)); + cls->defineFunction("getSkyboxMaterial", _SE(js_cc_scene_Skybox_getSkyboxMaterial)); + cls->defineFunction("setRotationAngle", _SE(js_cc_scene_Skybox_setRotationAngle)); + cls->defineFunction("getRotationAngle", _SE(js_cc_scene_Skybox_getRotationAngle)); + cls->defineFunction("getReflectionMap", _SE(js_cc_scene_Skybox_getReflectionMap)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Skybox)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Skybox_proto = cls->getProto(); + __jsb_cc_scene_Skybox_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SkinInfo_class = nullptr; +se::Object* __jsb_cc_scene_SkinInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SkinInfo) + +static bool js_new_cc_scene_SkinInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SkinInfo *result; + result = (cc::scene::SkinInfo *)new cc::scene::SkinInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SkinInfo, __jsb_cc_scene_SkinInfo_class, js_delete_cc_scene_SkinInfo) + +static bool js_delete_cc_scene_SkinInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SkinInfo) + +static bool js_cc_scene_SkinInfo_setEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_setEnabled) + +static bool js_cc_scene_SkinInfo_isEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::SkinInfo const *)arg1)->isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_isEnabled) + +static bool js_cc_scene_SkinInfo_setBlurRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBlurRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_setBlurRadius) + +static bool js_cc_scene_SkinInfo_getBlurRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::SkinInfo const *)arg1)->getBlurRadius(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_getBlurRadius) + +static bool js_cc_scene_SkinInfo_setSSSIntensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSSSIntensity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_setSSSIntensity) + +static bool js_cc_scene_SkinInfo_getSSSIntensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::SkinInfo const *)arg1)->getSSSIntensity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_getSSSIntensity) + +static bool js_cc_scene_SkinInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + cc::scene::Skin *arg2 = (cc::scene::Skin *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_activate) + +static bool js_cc_scene_SkinInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__enabled_set) + +static bool js_cc_scene_SkinInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__enabled_get) + +static bool js_cc_scene_SkinInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__resource_set) + +static bool js_cc_scene_SkinInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__resource_get) + +static bool js_cc_scene_SkinInfo__blurRadius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_blurRadius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__blurRadius_set) + +static bool js_cc_scene_SkinInfo__blurRadius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_blurRadius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__blurRadius_get) + +static bool js_cc_scene_SkinInfo__sssIntensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_sssIntensity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__sssIntensity_set) + +static bool js_cc_scene_SkinInfo__sssIntensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_sssIntensity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__sssIntensity_get) + +bool js_register_cc_scene_SkinInfo(se::Object* obj) { + auto* cls = se::Class::create("SkinInfo", obj, nullptr, _SE(js_new_cc_scene_SkinInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_enabled", _SE(js_cc_scene_SkinInfo__enabled_get), _SE(js_cc_scene_SkinInfo__enabled_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_SkinInfo__resource_get), _SE(js_cc_scene_SkinInfo__resource_set)); + cls->defineProperty("_blurRadius", _SE(js_cc_scene_SkinInfo__blurRadius_get), _SE(js_cc_scene_SkinInfo__blurRadius_set)); + cls->defineProperty("_sssIntensity", _SE(js_cc_scene_SkinInfo__sssIntensity_get), _SE(js_cc_scene_SkinInfo__sssIntensity_set)); + + cls->defineFunction("setEnabled", _SE(js_cc_scene_SkinInfo_setEnabled)); + cls->defineFunction("isEnabled", _SE(js_cc_scene_SkinInfo_isEnabled)); + cls->defineFunction("setBlurRadius", _SE(js_cc_scene_SkinInfo_setBlurRadius)); + cls->defineFunction("getBlurRadius", _SE(js_cc_scene_SkinInfo_getBlurRadius)); + cls->defineFunction("setSSSIntensity", _SE(js_cc_scene_SkinInfo_setSSSIntensity)); + cls->defineFunction("getSSSIntensity", _SE(js_cc_scene_SkinInfo_getSSSIntensity)); + cls->defineFunction("activate", _SE(js_cc_scene_SkinInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SkinInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SkinInfo_proto = cls->getProto(); + __jsb_cc_scene_SkinInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Skin_class = nullptr; +se::Object* __jsb_cc_scene_Skin_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Skin) + +static bool js_new_cc_scene_Skin(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Skin *result; + result = (cc::scene::Skin *)new cc::scene::Skin(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Skin, __jsb_cc_scene_Skin_class, js_delete_cc_scene_Skin) + +static bool js_delete_cc_scene_Skin(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Skin) + +static bool js_cc_scene_Skin_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + cc::scene::SkinInfo *arg2 = 0 ; + cc::scene::SkinInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::SkinInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skin_initialize) + +static bool js_cc_scene_Skin_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skin_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skin_enabled_set) + +static bool js_cc_scene_Skin_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skin_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skin_enabled_get) + +static bool js_cc_scene_Skin_blurRadius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skin_blurRadius_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skin_blurRadius_set) + +static bool js_cc_scene_Skin_blurRadius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Skin_blurRadius_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skin_blurRadius_get) + +static bool js_cc_scene_Skin_sssIntensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skin_sssIntensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skin_sssIntensity_set) + +static bool js_cc_scene_Skin_sssIntensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Skin_sssIntensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skin_sssIntensity_get) + +bool js_register_cc_scene_Skin(se::Object* obj) { + auto* cls = se::Class::create("Skin", obj, nullptr, _SE(js_new_cc_scene_Skin)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enabled", _SE(js_cc_scene_Skin_enabled_get), _SE(js_cc_scene_Skin_enabled_set)); + cls->defineProperty("blurRadius", _SE(js_cc_scene_Skin_blurRadius_get), _SE(js_cc_scene_Skin_blurRadius_set)); + cls->defineProperty("sssIntensity", _SE(js_cc_scene_Skin_sssIntensity_get), _SE(js_cc_scene_Skin_sssIntensity_set)); + + cls->defineFunction("initialize", _SE(js_cc_scene_Skin_initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Skin)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Skin_proto = cls->getProto(); + __jsb_cc_scene_Skin_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PostSettingsInfo_class = nullptr; +se::Object* __jsb_cc_scene_PostSettingsInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PostSettingsInfo) + +static bool js_new_cc_scene_PostSettingsInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PostSettingsInfo *result; + result = (cc::scene::PostSettingsInfo *)new cc::scene::PostSettingsInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PostSettingsInfo, __jsb_cc_scene_PostSettingsInfo_class, js_delete_cc_scene_PostSettingsInfo) + +static bool js_delete_cc_scene_PostSettingsInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PostSettingsInfo) + +static bool js_cc_scene_PostSettingsInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + cc::scene::PostSettings *arg2 = (cc::scene::PostSettings *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_PostSettingsInfo_activate) + +static bool js_cc_scene_PostSettingsInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettingsInfo__resource_set) + +static bool js_cc_scene_PostSettingsInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PostSettingsInfo__resource_get) + +static bool js_cc_scene_PostSettingsInfo__toneMappingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_toneMappingType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettingsInfo__toneMappingType_set) + +static bool js_cc_scene_PostSettingsInfo__toneMappingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_toneMappingType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_toneMappingType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PostSettingsInfo__toneMappingType_get) + +static bool js_cc_scene_PostSettingsInfo_toneMappingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + cc::scene::ToneMappingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_PostSettingsInfo_toneMappingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettingsInfo_toneMappingType_set) + +static bool js_cc_scene_PostSettingsInfo_toneMappingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + cc::scene::ToneMappingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ToneMappingType)cc_scene_PostSettingsInfo_toneMappingType_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_scene_PostSettingsInfo_toneMappingType_get) + +bool js_register_cc_scene_PostSettingsInfo(se::Object* obj) { + auto* cls = se::Class::create("PostSettingsInfo", obj, nullptr, _SE(js_new_cc_scene_PostSettingsInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_resource", _SE(js_cc_scene_PostSettingsInfo__resource_get), _SE(js_cc_scene_PostSettingsInfo__resource_set)); + cls->defineProperty("_toneMappingType", _SE(js_cc_scene_PostSettingsInfo__toneMappingType_get), _SE(js_cc_scene_PostSettingsInfo__toneMappingType_set)); + cls->defineProperty("toneMappingType", _SE(js_cc_scene_PostSettingsInfo_toneMappingType_get), _SE(js_cc_scene_PostSettingsInfo_toneMappingType_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_PostSettingsInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PostSettingsInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PostSettingsInfo_proto = cls->getProto(); + __jsb_cc_scene_PostSettingsInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PostSettings_class = nullptr; +se::Object* __jsb_cc_scene_PostSettings_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PostSettings) + +static bool js_new_cc_scene_PostSettings(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PostSettings *result; + result = (cc::scene::PostSettings *)new cc::scene::PostSettings(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PostSettings, __jsb_cc_scene_PostSettings_class, js_delete_cc_scene_PostSettings) + +static bool js_delete_cc_scene_PostSettings(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PostSettings) + +static bool js_cc_scene_PostSettings_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_PostSettings_activate) + +static bool js_cc_scene_PostSettings_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + cc::scene::PostSettingsInfo *arg2 = 0 ; + cc::scene::PostSettingsInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::PostSettingsInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_PostSettings_initialize) + +static bool js_cc_scene_PostSettings_toneMappingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + cc::scene::ToneMappingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_PostSettings_toneMappingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettings_toneMappingType_set) + +static bool js_cc_scene_PostSettings_toneMappingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + cc::scene::ToneMappingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ToneMappingType)cc_scene_PostSettings_toneMappingType_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_scene_PostSettings_toneMappingType_get) + +bool js_register_cc_scene_PostSettings(se::Object* obj) { + auto* cls = se::Class::create("PostSettings", obj, nullptr, _SE(js_new_cc_scene_PostSettings)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("toneMappingType", _SE(js_cc_scene_PostSettings_toneMappingType_get), _SE(js_cc_scene_PostSettings_toneMappingType_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_PostSettings_activate)); + cls->defineFunction("initialize", _SE(js_cc_scene_PostSettings_initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PostSettings)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PostSettings_proto = cls->getProto(); + __jsb_cc_scene_PostSettings_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_DirectionalLight_class = nullptr; +se::Object* __jsb_cc_scene_DirectionalLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_DirectionalLight) + +static bool js_new_cc_scene_DirectionalLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::DirectionalLight *result; + result = (cc::scene::DirectionalLight *)new cc::scene::DirectionalLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_DirectionalLight, __jsb_cc_scene_DirectionalLight_class, js_delete_cc_scene_DirectionalLight) + +static bool js_delete_cc_scene_DirectionalLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_DirectionalLight) + +static bool js_cc_scene_DirectionalLight_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ((cc::scene::DirectionalLight const *)arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_DirectionalLight_activate) + +static bool js_cc_scene_DirectionalLight_direction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_DirectionalLight_direction_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_direction_set) + +static bool js_cc_scene_DirectionalLight_direction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_DirectionalLight_direction_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_scene_DirectionalLight_direction_get) + +static bool js_cc_scene_DirectionalLight_illuminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_illuminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_illuminance_set) + +static bool js_cc_scene_DirectionalLight_illuminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_illuminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_illuminance_get) + +static bool js_cc_scene_DirectionalLight_illuminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_illuminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_illuminanceHDR_set) + +static bool js_cc_scene_DirectionalLight_illuminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_illuminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_illuminanceHDR_get) + +static bool js_cc_scene_DirectionalLight_illuminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_illuminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_illuminanceLDR_set) + +static bool js_cc_scene_DirectionalLight_illuminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_illuminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_illuminanceLDR_get) + +static bool js_cc_scene_DirectionalLight_shadowEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowEnabled_set) + +static bool js_cc_scene_DirectionalLight_shadowEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_shadowEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowEnabled_get) + +static bool js_cc_scene_DirectionalLight_shadowPcf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::PCFType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_DirectionalLight_shadowPcf_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowPcf_set) + +static bool js_cc_scene_DirectionalLight_shadowPcf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::PCFType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::PCFType)cc_scene_DirectionalLight_shadowPcf_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_scene_DirectionalLight_shadowPcf_get) + +static bool js_cc_scene_DirectionalLight_shadowBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowBias_set) + +static bool js_cc_scene_DirectionalLight_shadowBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowBias_get) + +static bool js_cc_scene_DirectionalLight_shadowNormalBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowNormalBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowNormalBias_set) + +static bool js_cc_scene_DirectionalLight_shadowNormalBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowNormalBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowNormalBias_get) + +static bool js_cc_scene_DirectionalLight_shadowSaturation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowSaturation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowSaturation_set) + +static bool js_cc_scene_DirectionalLight_shadowSaturation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowSaturation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowSaturation_get) + +static bool js_cc_scene_DirectionalLight_shadowDistance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowDistance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowDistance_set) + +static bool js_cc_scene_DirectionalLight_shadowDistance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowDistance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowDistance_get) + +static bool js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set) + +static bool js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get) + +static bool js_cc_scene_DirectionalLight_shadowFixedArea_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowFixedArea_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowFixedArea_set) + +static bool js_cc_scene_DirectionalLight_shadowFixedArea_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_shadowFixedArea_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowFixedArea_get) + +static bool js_cc_scene_DirectionalLight_shadowNear_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowNear_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowNear_set) + +static bool js_cc_scene_DirectionalLight_shadowNear_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowNear_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowNear_get) + +static bool js_cc_scene_DirectionalLight_shadowFar_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowFar_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowFar_set) + +static bool js_cc_scene_DirectionalLight_shadowFar_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowFar_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowFar_get) + +static bool js_cc_scene_DirectionalLight_shadowOrthoSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowOrthoSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowOrthoSize_set) + +static bool js_cc_scene_DirectionalLight_shadowOrthoSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowOrthoSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowOrthoSize_get) + +static bool js_cc_scene_DirectionalLight_csmLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMLevel arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_DirectionalLight_csmLevel_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmLevel_set) + +static bool js_cc_scene_DirectionalLight_csmLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMLevel result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CSMLevel)cc_scene_DirectionalLight_csmLevel_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_scene_DirectionalLight_csmLevel_get) + +static bool js_cc_scene_DirectionalLight_csmNeedUpdate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmNeedUpdate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmNeedUpdate_set) + +static bool js_cc_scene_DirectionalLight_csmNeedUpdate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_csmNeedUpdate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmNeedUpdate_get) + +static bool js_cc_scene_DirectionalLight_csmLayerLambda_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmLayerLambda_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmLayerLambda_set) + +static bool js_cc_scene_DirectionalLight_csmLayerLambda_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_csmLayerLambda_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmLayerLambda_get) + +static bool js_cc_scene_DirectionalLight_csmOptimizationMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMOptimizationMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_DirectionalLight_csmOptimizationMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmOptimizationMode_set) + +static bool js_cc_scene_DirectionalLight_csmOptimizationMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMOptimizationMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CSMOptimizationMode)cc_scene_DirectionalLight_csmOptimizationMode_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_scene_DirectionalLight_csmOptimizationMode_get) + +static bool js_cc_scene_DirectionalLight_csmLayersTransition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmLayersTransition_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmLayersTransition_set) + +static bool js_cc_scene_DirectionalLight_csmLayersTransition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_csmLayersTransition_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmLayersTransition_get) + +static bool js_cc_scene_DirectionalLight_csmTransitionRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmTransitionRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmTransitionRange_set) + +static bool js_cc_scene_DirectionalLight_csmTransitionRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_csmTransitionRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmTransitionRange_get) + +bool js_register_cc_scene_DirectionalLight(se::Object* obj) { + auto* cls = se::Class::create("DirectionalLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_DirectionalLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("direction", _SE(js_cc_scene_DirectionalLight_direction_get), _SE(js_cc_scene_DirectionalLight_direction_set)); + cls->defineProperty("illuminance", _SE(js_cc_scene_DirectionalLight_illuminance_get), _SE(js_cc_scene_DirectionalLight_illuminance_set)); + cls->defineProperty("illuminanceHDR", _SE(js_cc_scene_DirectionalLight_illuminanceHDR_get), _SE(js_cc_scene_DirectionalLight_illuminanceHDR_set)); + cls->defineProperty("illuminanceLDR", _SE(js_cc_scene_DirectionalLight_illuminanceLDR_get), _SE(js_cc_scene_DirectionalLight_illuminanceLDR_set)); + cls->defineProperty("shadowEnabled", _SE(js_cc_scene_DirectionalLight_shadowEnabled_get), _SE(js_cc_scene_DirectionalLight_shadowEnabled_set)); + cls->defineProperty("shadowPcf", _SE(js_cc_scene_DirectionalLight_shadowPcf_get), _SE(js_cc_scene_DirectionalLight_shadowPcf_set)); + cls->defineProperty("shadowBias", _SE(js_cc_scene_DirectionalLight_shadowBias_get), _SE(js_cc_scene_DirectionalLight_shadowBias_set)); + cls->defineProperty("shadowNormalBias", _SE(js_cc_scene_DirectionalLight_shadowNormalBias_get), _SE(js_cc_scene_DirectionalLight_shadowNormalBias_set)); + cls->defineProperty("shadowSaturation", _SE(js_cc_scene_DirectionalLight_shadowSaturation_get), _SE(js_cc_scene_DirectionalLight_shadowSaturation_set)); + cls->defineProperty("shadowDistance", _SE(js_cc_scene_DirectionalLight_shadowDistance_get), _SE(js_cc_scene_DirectionalLight_shadowDistance_set)); + cls->defineProperty("shadowInvisibleOcclusionRange", _SE(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get), _SE(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set)); + cls->defineProperty("shadowFixedArea", _SE(js_cc_scene_DirectionalLight_shadowFixedArea_get), _SE(js_cc_scene_DirectionalLight_shadowFixedArea_set)); + cls->defineProperty("shadowNear", _SE(js_cc_scene_DirectionalLight_shadowNear_get), _SE(js_cc_scene_DirectionalLight_shadowNear_set)); + cls->defineProperty("shadowFar", _SE(js_cc_scene_DirectionalLight_shadowFar_get), _SE(js_cc_scene_DirectionalLight_shadowFar_set)); + cls->defineProperty("shadowOrthoSize", _SE(js_cc_scene_DirectionalLight_shadowOrthoSize_get), _SE(js_cc_scene_DirectionalLight_shadowOrthoSize_set)); + cls->defineProperty("csmLevel", _SE(js_cc_scene_DirectionalLight_csmLevel_get), _SE(js_cc_scene_DirectionalLight_csmLevel_set)); + cls->defineProperty("csmNeedUpdate", _SE(js_cc_scene_DirectionalLight_csmNeedUpdate_get), _SE(js_cc_scene_DirectionalLight_csmNeedUpdate_set)); + cls->defineProperty("csmLayerLambda", _SE(js_cc_scene_DirectionalLight_csmLayerLambda_get), _SE(js_cc_scene_DirectionalLight_csmLayerLambda_set)); + cls->defineProperty("csmOptimizationMode", _SE(js_cc_scene_DirectionalLight_csmOptimizationMode_get), _SE(js_cc_scene_DirectionalLight_csmOptimizationMode_set)); + cls->defineProperty("csmLayersTransition", _SE(js_cc_scene_DirectionalLight_csmLayersTransition_get), _SE(js_cc_scene_DirectionalLight_csmLayersTransition_set)); + cls->defineProperty("csmTransitionRange", _SE(js_cc_scene_DirectionalLight_csmTransitionRange_get), _SE(js_cc_scene_DirectionalLight_csmTransitionRange_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_DirectionalLight_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_DirectionalLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_DirectionalLight_proto = cls->getProto(); + __jsb_cc_scene_DirectionalLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SpotLight_class = nullptr; +se::Object* __jsb_cc_scene_SpotLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SpotLight) + +static bool js_new_cc_scene_SpotLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SpotLight *result; + result = (cc::scene::SpotLight *)new cc::scene::SpotLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SpotLight, __jsb_cc_scene_SpotLight_class, js_delete_cc_scene_SpotLight) + +static bool js_delete_cc_scene_SpotLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SpotLight) + +static bool js_cc_scene_SpotLight_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_SpotLight_position_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_scene_SpotLight_position_get) + +static bool js_cc_scene_SpotLight_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_range_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_range_set) + +static bool js_cc_scene_SpotLight_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_range_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_range_get) + +static bool js_cc_scene_SpotLight_luminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_luminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_luminance_set) + +static bool js_cc_scene_SpotLight_luminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_luminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_luminance_get) + +static bool js_cc_scene_SpotLight_luminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_luminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_luminanceHDR_set) + +static bool js_cc_scene_SpotLight_luminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_luminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_luminanceHDR_get) + +static bool js_cc_scene_SpotLight_luminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_luminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_luminanceLDR_set) + +static bool js_cc_scene_SpotLight_luminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_luminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_luminanceLDR_get) + +static bool js_cc_scene_SpotLight_direction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_SpotLight_direction_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_scene_SpotLight_direction_get) + +static bool js_cc_scene_SpotLight_spotAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_spotAngle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_spotAngle_set) + +static bool js_cc_scene_SpotLight_spotAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_spotAngle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_spotAngle_get) + +static bool js_cc_scene_SpotLight_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_angle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_angle_get) + +static bool js_cc_scene_SpotLight_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &cc_scene_SpotLight_aabb_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_scene_SpotLight_aabb_get) + +static bool js_cc_scene_SpotLight_frustum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SpotLight_frustum_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_frustum_set) + +static bool js_cc_scene_SpotLight_frustum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::geometry::Frustum *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Frustum *) &cc_scene_SpotLight_frustum_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_scene_SpotLight_frustum_get) + +static bool js_cc_scene_SpotLight_shadowEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowEnabled_set) + +static bool js_cc_scene_SpotLight_shadowEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SpotLight_shadowEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowEnabled_get) + +static bool js_cc_scene_SpotLight_shadowPcf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowPcf_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowPcf_set) + +static bool js_cc_scene_SpotLight_shadowPcf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_shadowPcf_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowPcf_get) + +static bool js_cc_scene_SpotLight_shadowBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowBias_set) + +static bool js_cc_scene_SpotLight_shadowBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_shadowBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowBias_get) + +static bool js_cc_scene_SpotLight_shadowNormalBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowNormalBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowNormalBias_set) + +static bool js_cc_scene_SpotLight_shadowNormalBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_shadowNormalBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowNormalBias_get) + +static bool js_cc_scene_SpotLight_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_size_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_size_set) + +static bool js_cc_scene_SpotLight_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_size_get) + +static bool js_cc_scene_SpotLight_angleAttenuationStrength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_angleAttenuationStrength_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_angleAttenuationStrength_set) + +static bool js_cc_scene_SpotLight_angleAttenuationStrength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_angleAttenuationStrength_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_angleAttenuationStrength_get) + +bool js_register_cc_scene_SpotLight(se::Object* obj) { + auto* cls = se::Class::create("SpotLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_SpotLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_scene_SpotLight_position_get), nullptr); + cls->defineProperty("range", _SE(js_cc_scene_SpotLight_range_get), _SE(js_cc_scene_SpotLight_range_set)); + cls->defineProperty("luminance", _SE(js_cc_scene_SpotLight_luminance_get), _SE(js_cc_scene_SpotLight_luminance_set)); + cls->defineProperty("luminanceHDR", _SE(js_cc_scene_SpotLight_luminanceHDR_get), _SE(js_cc_scene_SpotLight_luminanceHDR_set)); + cls->defineProperty("luminanceLDR", _SE(js_cc_scene_SpotLight_luminanceLDR_get), _SE(js_cc_scene_SpotLight_luminanceLDR_set)); + cls->defineProperty("direction", _SE(js_cc_scene_SpotLight_direction_get), nullptr); + cls->defineProperty("spotAngle", _SE(js_cc_scene_SpotLight_spotAngle_get), _SE(js_cc_scene_SpotLight_spotAngle_set)); + cls->defineProperty("angle", _SE(js_cc_scene_SpotLight_angle_get), nullptr); + cls->defineProperty("aabb", _SE(js_cc_scene_SpotLight_aabb_get), nullptr); + cls->defineProperty("frustum", _SE(js_cc_scene_SpotLight_frustum_get), _SE(js_cc_scene_SpotLight_frustum_set)); + cls->defineProperty("shadowEnabled", _SE(js_cc_scene_SpotLight_shadowEnabled_get), _SE(js_cc_scene_SpotLight_shadowEnabled_set)); + cls->defineProperty("shadowPcf", _SE(js_cc_scene_SpotLight_shadowPcf_get), _SE(js_cc_scene_SpotLight_shadowPcf_set)); + cls->defineProperty("shadowBias", _SE(js_cc_scene_SpotLight_shadowBias_get), _SE(js_cc_scene_SpotLight_shadowBias_set)); + cls->defineProperty("shadowNormalBias", _SE(js_cc_scene_SpotLight_shadowNormalBias_get), _SE(js_cc_scene_SpotLight_shadowNormalBias_set)); + cls->defineProperty("size", _SE(js_cc_scene_SpotLight_size_get), _SE(js_cc_scene_SpotLight_size_set)); + cls->defineProperty("angleAttenuationStrength", _SE(js_cc_scene_SpotLight_angleAttenuationStrength_get), _SE(js_cc_scene_SpotLight_angleAttenuationStrength_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SpotLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SpotLight_proto = cls->getProto(); + __jsb_cc_scene_SpotLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SphereLight_class = nullptr; +se::Object* __jsb_cc_scene_SphereLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SphereLight) + +static bool js_new_cc_scene_SphereLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SphereLight *result; + result = (cc::scene::SphereLight *)new cc::scene::SphereLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SphereLight, __jsb_cc_scene_SphereLight_class, js_delete_cc_scene_SphereLight) + +static bool js_delete_cc_scene_SphereLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SphereLight) + +static bool js_cc_scene_SphereLight_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SphereLight_position_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_position_set) + +static bool js_cc_scene_SphereLight_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_SphereLight_position_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_scene_SphereLight_position_get) + +static bool js_cc_scene_SphereLight_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_size_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_size_set) + +static bool js_cc_scene_SphereLight_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_size_get) + +static bool js_cc_scene_SphereLight_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_range_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_range_set) + +static bool js_cc_scene_SphereLight_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_range_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_range_get) + +static bool js_cc_scene_SphereLight_luminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_luminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_luminance_set) + +static bool js_cc_scene_SphereLight_luminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_luminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_luminance_get) + +static bool js_cc_scene_SphereLight_luminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_luminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_luminanceHDR_set) + +static bool js_cc_scene_SphereLight_luminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_luminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_luminanceHDR_get) + +static bool js_cc_scene_SphereLight_luminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_luminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_luminanceLDR_set) + +static bool js_cc_scene_SphereLight_luminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_luminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_luminanceLDR_get) + +static bool js_cc_scene_SphereLight_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &cc_scene_SphereLight_aabb_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_scene_SphereLight_aabb_get) + +bool js_register_cc_scene_SphereLight(se::Object* obj) { + auto* cls = se::Class::create("SphereLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_SphereLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_scene_SphereLight_position_get), _SE(js_cc_scene_SphereLight_position_set)); + cls->defineProperty("size", _SE(js_cc_scene_SphereLight_size_get), _SE(js_cc_scene_SphereLight_size_set)); + cls->defineProperty("range", _SE(js_cc_scene_SphereLight_range_get), _SE(js_cc_scene_SphereLight_range_set)); + cls->defineProperty("luminance", _SE(js_cc_scene_SphereLight_luminance_get), _SE(js_cc_scene_SphereLight_luminance_set)); + cls->defineProperty("luminanceHDR", _SE(js_cc_scene_SphereLight_luminanceHDR_get), _SE(js_cc_scene_SphereLight_luminanceHDR_set)); + cls->defineProperty("luminanceLDR", _SE(js_cc_scene_SphereLight_luminanceLDR_get), _SE(js_cc_scene_SphereLight_luminanceLDR_set)); + cls->defineProperty("aabb", _SE(js_cc_scene_SphereLight_aabb_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SphereLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SphereLight_proto = cls->getProto(); + __jsb_cc_scene_SphereLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PointLight_class = nullptr; +se::Object* __jsb_cc_scene_PointLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PointLight) + +static bool js_new_cc_scene_PointLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PointLight *result; + result = (cc::scene::PointLight *)new cc::scene::PointLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PointLight, __jsb_cc_scene_PointLight_class, js_delete_cc_scene_PointLight) + +static bool js_delete_cc_scene_PointLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PointLight) + +static bool js_cc_scene_PointLight_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_PointLight_position_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_position_set) + +static bool js_cc_scene_PointLight_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_PointLight_position_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_scene_PointLight_position_get) + +static bool js_cc_scene_PointLight_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_range_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_range_set) + +static bool js_cc_scene_PointLight_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_range_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_range_get) + +static bool js_cc_scene_PointLight_luminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_luminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_luminance_set) + +static bool js_cc_scene_PointLight_luminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_luminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_luminance_get) + +static bool js_cc_scene_PointLight_luminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_luminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_luminanceHDR_set) + +static bool js_cc_scene_PointLight_luminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_luminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_luminanceHDR_get) + +static bool js_cc_scene_PointLight_luminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_luminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_luminanceLDR_set) + +static bool js_cc_scene_PointLight_luminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_luminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_luminanceLDR_get) + +static bool js_cc_scene_PointLight_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &cc_scene_PointLight_aabb_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_scene_PointLight_aabb_get) + +bool js_register_cc_scene_PointLight(se::Object* obj) { + auto* cls = se::Class::create("PointLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_PointLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_scene_PointLight_position_get), _SE(js_cc_scene_PointLight_position_set)); + cls->defineProperty("range", _SE(js_cc_scene_PointLight_range_get), _SE(js_cc_scene_PointLight_range_set)); + cls->defineProperty("luminance", _SE(js_cc_scene_PointLight_luminance_get), _SE(js_cc_scene_PointLight_luminance_set)); + cls->defineProperty("luminanceHDR", _SE(js_cc_scene_PointLight_luminanceHDR_get), _SE(js_cc_scene_PointLight_luminanceHDR_set)); + cls->defineProperty("luminanceLDR", _SE(js_cc_scene_PointLight_luminanceLDR_get), _SE(js_cc_scene_PointLight_luminanceLDR_set)); + cls->defineProperty("aabb", _SE(js_cc_scene_PointLight_aabb_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PointLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PointLight_proto = cls->getProto(); + __jsb_cc_scene_PointLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_RangedDirectionalLight_class = nullptr; +se::Object* __jsb_cc_scene_RangedDirectionalLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_RangedDirectionalLight) + +static bool js_new_cc_scene_RangedDirectionalLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::RangedDirectionalLight *result; + result = (cc::scene::RangedDirectionalLight *)new cc::scene::RangedDirectionalLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_RangedDirectionalLight, __jsb_cc_scene_RangedDirectionalLight_class, js_delete_cc_scene_RangedDirectionalLight) + +static bool js_delete_cc_scene_RangedDirectionalLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_RangedDirectionalLight) + +static bool js_cc_scene_RangedDirectionalLight_getDirection(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getDirection(); + + 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_scene_RangedDirectionalLight_getDirection) + +static bool js_cc_scene_RangedDirectionalLight_getPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getPosition(); + + 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_scene_RangedDirectionalLight_getPosition) + +static bool js_cc_scene_RangedDirectionalLight_getScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getScale(); + + 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_scene_RangedDirectionalLight_getScale) + +static bool js_cc_scene_RangedDirectionalLight_getRight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getRight(); + + 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_scene_RangedDirectionalLight_getRight) + +static bool js_cc_scene_RangedDirectionalLight_illuminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_RangedDirectionalLight_illuminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_RangedDirectionalLight_illuminance_set) + +static bool js_cc_scene_RangedDirectionalLight_illuminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_RangedDirectionalLight_illuminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RangedDirectionalLight_illuminance_get) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_RangedDirectionalLight_illuminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_RangedDirectionalLight_illuminanceHDR_set) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_RangedDirectionalLight_illuminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RangedDirectionalLight_illuminanceHDR_get) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_RangedDirectionalLight_illuminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_RangedDirectionalLight_illuminanceLDR_set) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_RangedDirectionalLight_illuminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RangedDirectionalLight_illuminanceLDR_get) + +bool js_register_cc_scene_RangedDirectionalLight(se::Object* obj) { + auto* cls = se::Class::create("RangedDirectionalLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_RangedDirectionalLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("illuminance", _SE(js_cc_scene_RangedDirectionalLight_illuminance_get), _SE(js_cc_scene_RangedDirectionalLight_illuminance_set)); + cls->defineProperty("illuminanceHDR", _SE(js_cc_scene_RangedDirectionalLight_illuminanceHDR_get), _SE(js_cc_scene_RangedDirectionalLight_illuminanceHDR_set)); + cls->defineProperty("illuminanceLDR", _SE(js_cc_scene_RangedDirectionalLight_illuminanceLDR_get), _SE(js_cc_scene_RangedDirectionalLight_illuminanceLDR_set)); + + cls->defineFunction("getDirection", _SE(js_cc_scene_RangedDirectionalLight_getDirection)); + cls->defineFunction("getPosition", _SE(js_cc_scene_RangedDirectionalLight_getPosition)); + cls->defineFunction("getScale", _SE(js_cc_scene_RangedDirectionalLight_getScale)); + cls->defineFunction("getRight", _SE(js_cc_scene_RangedDirectionalLight_getRight)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_RangedDirectionalLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_RangedDirectionalLight_proto = cls->getProto(); + __jsb_cc_scene_RangedDirectionalLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Model_class = nullptr; +se::Object* __jsb_cc_scene_Model_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Model) + +static bool js_new_cc_scene_Model(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Model *result; + result = (cc::scene::Model *)new cc::scene::Model(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Model, __jsb_cc_scene_Model_class, js_delete_cc_scene_Model) + +static bool js_delete_cc_scene_Model(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Model) + +static bool js_cc_scene_Model_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_destroy) + +static bool js_cc_scene_Model_initSubModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::RenderingSubMesh *arg3 = (cc::RenderingSubMesh *) NULL ; + cc::Material *arg4 = (cc::Material *) NULL ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initSubModel(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initSubModel) + +static bool js_cc_scene_Model_getMacroPatches(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + ccstd::vector< cc::scene::IMacroPatch > result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getMacroPatches(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_getMacroPatches) + +static bool js_cc_scene_Model_setSubModelMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::Material *arg3 = (cc::Material *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSubModelMaterial(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setSubModelMaterial) + +static bool js_cc_scene_Model__updateInstancedAttributes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::vector< cc::gfx::Attribute > *arg2 = 0 ; + cc::scene::SubModel *arg3 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::gfx::Attribute > temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateInstancedAttributes((ccstd::vector< cc::gfx::Attribute > const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateInstancedAttributes) + +static bool js_cc_scene_Model_updateTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateTransform(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateTransform) + +static bool js_cc_scene_Model_updateUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateUBOs(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateUBOs) + +static bool js_cc_scene_Model__updateLocalDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLocalDescriptors(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateLocalDescriptors) + +static bool js_cc_scene_Model__updateLocalSHDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLocalSHDescriptors(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateLocalSHDescriptors) + +static bool js_cc_scene_Model__updateWorldBoundDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateWorldBoundDescriptors(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateWorldBoundDescriptors) + +static bool js_cc_scene_Model_createBoundingShape(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::optional< cc::Vec3 > *arg2 = 0 ; + ccstd::optional< cc::Vec3 > *arg3 = 0 ; + ccstd::optional< cc::Vec3 > temp2 ; + ccstd::optional< cc::Vec3 > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->createBoundingShape((ccstd::optional< cc::Vec3 > const &)*arg2,(ccstd::optional< cc::Vec3 > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_createBoundingShape) + +static bool js_cc_scene_Model_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initialize) + +static bool js_cc_scene_Model_initLightingmap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Texture2D *arg2 = (cc::Texture2D *) NULL ; + cc::Vec4 *arg3 = 0 ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->initLightingmap(arg2,(cc::Vec4 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initLightingmap) + +static bool js_cc_scene_Model__initLocalDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initLocalDescriptors(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__initLocalDescriptors) + +static bool js_cc_scene_Model__initLocalSHDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initLocalSHDescriptors(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__initLocalSHDescriptors) + +static bool js_cc_scene_Model_initWorldBoundDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWorldBoundDescriptors(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initWorldBoundDescriptors) + +static bool js_cc_scene_Model_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ((cc::scene::Model const *)arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_onGlobalPipelineStateChanged) + +static bool js_cc_scene_Model_onMacroPatchesStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onMacroPatchesStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_onMacroPatchesStateChanged) + +static bool js_cc_scene_Model_onGeometryChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGeometryChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_onGeometryChanged) + +static bool js_cc_scene_Model_setSubModelMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::RenderingSubMesh *arg3 = (cc::RenderingSubMesh *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + ((cc::scene::Model const *)arg1)->setSubModelMesh(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setSubModelMesh) + +static bool js_cc_scene_Model_setInstancedAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TypedArray *arg3 = 0 ; + ccstd::string temp2 ; + cc::TypedArray temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setInstancedAttribute((ccstd::string const &)*arg2,(cc::TypedArray const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setInstancedAttribute) + +static bool js_cc_scene_Model_updateWorldBound(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldBound(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBound) + +static bool js_cc_scene_Model_updateWorldBoundsForJSSkinningModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateWorldBoundsForJSSkinningModel((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBoundsForJSSkinningModel) + +static bool js_cc_scene_Model_updateWorldBoundsForJSBakedSkinningModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateWorldBoundsForJSBakedSkinningModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBoundsForJSBakedSkinningModel) + +static bool js_cc_scene_Model_updateLightingmap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Texture2D *arg2 = (cc::Texture2D *) NULL ; + cc::Vec4 *arg3 = 0 ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->updateLightingmap(arg2,(cc::Vec4 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateLightingmap) + +static bool js_cc_scene_Model_clearSHUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearSHUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_clearSHUBOs) + +static bool js_cc_scene_Model_updateSHUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateSHUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateSHUBOs) + +static bool js_cc_scene_Model_updateWorldBoundUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldBoundUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBoundUBOs) + +static bool js_cc_scene_Model_updateLocalShadowBias(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateLocalShadowBias(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateLocalShadowBias) + +static bool js_cc_scene_Model_updateReflectionProbeCubemap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbeCubemap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeCubemap) + +static bool js_cc_scene_Model_updateReflectionProbePlanarMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbePlanarMap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbePlanarMap) + +static bool js_cc_scene_Model_updateReflectionProbeId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateReflectionProbeId(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeId) + +static bool js_cc_scene_Model_updateReflectionProbeDataMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Texture2D *arg2 = (cc::Texture2D *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbeDataMap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeDataMap) + +static bool js_cc_scene_Model_updateReflectionProbeBlendCubemap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbeBlendCubemap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeBlendCubemap) + +static bool js_cc_scene_Model_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_attachToScene) + +static bool js_cc_scene_Model_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_detachFromScene) + +static bool js_cc_scene_Model_setLocalSHBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLocalSHBuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setLocalSHBuffer) + +static bool js_cc_scene_Model_setBounds(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBounds(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setBounds) + +static bool js_cc_scene_Model_showTetrahedron(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Model const *)arg1)->showTetrahedron(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_showTetrahedron) + +static bool js_cc_scene_Model_getLocalSHBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::scene::Model const *)arg1)->getLocalSHBuffer(); + + 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_scene_Model_getLocalSHBuffer) + +static bool js_cc_scene_Model_getLocalSHData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Float32Array result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Model const *)arg1)->getLocalSHData(); + + 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_scene_Model_getLocalSHData) + +static bool js_cc_scene_Model_invalidateLocalData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidateLocalData(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_invalidateLocalData) + +static bool js_cc_scene_Model_setCalledFromJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCalledFromJS(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setCalledFromJS) + +static bool js_cc_scene_Model_isModelImplementedInJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Model const *)arg1)->isModelImplementedInJS(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_isModelImplementedInJS) + +static bool js_cc_scene_Model_scene_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_scene_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_scene_set) + +static bool js_cc_scene_Model_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_Model_scene_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_scene_Model_scene_get) + +static bool js_cc_scene_Model__subModels_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *) &cc_scene_Model__subModels_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_scene_Model__subModels_get) + +static bool js_cc_scene_Model_subModels_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *) &cc_scene_Model_subModels_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_scene_Model_subModels_get) + +static bool js_cc_scene_Model_inited_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_inited_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_inited_get) + +static bool js_cc_scene_Model__localDataUpdated_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model__localDataUpdated_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model__localDataUpdated_set) + +static bool js_cc_scene_Model__localDataUpdated_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model__localDataUpdated_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model__localDataUpdated_get) + +static bool js_cc_scene_Model__worldBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model__worldBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model__worldBounds_set) + +static bool js_cc_scene_Model__worldBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model__worldBounds_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_scene_Model__worldBounds_get) + +static bool js_cc_scene_Model_worldBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_worldBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_worldBounds_set) + +static bool js_cc_scene_Model_worldBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model_worldBounds_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_scene_Model_worldBounds_get) + +static bool js_cc_scene_Model__modelBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model__modelBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model__modelBounds_set) + +static bool js_cc_scene_Model__modelBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model__modelBounds_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_scene_Model__modelBounds_get) + +static bool js_cc_scene_Model_modelBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_modelBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_modelBounds_set) + +static bool js_cc_scene_Model_modelBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model_modelBounds_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_scene_Model_modelBounds_get) + +static bool js_cc_scene_Model_worldBoundBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_worldBoundBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_worldBoundBuffer_set) + +static bool js_cc_scene_Model_worldBoundBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_scene_Model_worldBoundBuffer_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_scene_Model_worldBoundBuffer_get) + +static bool js_cc_scene_Model_localBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_localBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_localBuffer_set) + +static bool js_cc_scene_Model_localBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_scene_Model_localBuffer_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_scene_Model_localBuffer_get) + +static bool js_cc_scene_Model_updateStamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_updateStamp_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_updateStamp_get) + +static bool js_cc_scene_Model_receiveShadow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_receiveShadow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_receiveShadow_set) + +static bool js_cc_scene_Model_receiveShadow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_receiveShadow_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_receiveShadow_get) + +static bool js_cc_scene_Model_castShadow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_castShadow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_castShadow_set) + +static bool js_cc_scene_Model_castShadow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_castShadow_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_castShadow_get) + +static bool js_cc_scene_Model_shadowBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_shadowBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_shadowBias_set) + +static bool js_cc_scene_Model_shadowBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Model_shadowBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_shadowBias_get) + +static bool js_cc_scene_Model_shadowNormalBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_shadowNormalBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_shadowNormalBias_set) + +static bool js_cc_scene_Model_shadowNormalBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Model_shadowNormalBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_shadowNormalBias_get) + +static bool js_cc_scene_Model_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_node_set) + +static bool js_cc_scene_Model_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Model_node_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_scene_Model_node_get) + +static bool js_cc_scene_Model_transform_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_transform_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_transform_set) + +static bool js_cc_scene_Model_transform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Model_transform_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_scene_Model_transform_get) + +static bool js_cc_scene_Model_visFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Layers::Enum arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_visFlags_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_visFlags_set) + +static bool js_cc_scene_Model_visFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Layers::Enum result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Layers::Enum)cc_scene_Model_visFlags_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_scene_Model_visFlags_get) + +static bool js_cc_scene_Model_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_enabled_set) + +static bool js_cc_scene_Model_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_enabled_get) + +static bool js_cc_scene_Model_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::Model::Type arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_type_set) + +static bool js_cc_scene_Model_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::Model::Type result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model::Type)cc_scene_Model_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_type_get) + +static bool js_cc_scene_Model_isDynamicBatching_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_isDynamicBatching_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_isDynamicBatching_set) + +static bool js_cc_scene_Model_isDynamicBatching_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_isDynamicBatching_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_isDynamicBatching_get) + +static bool js_cc_scene_Model_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_priority_set) + +static bool js_cc_scene_Model_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_priority_get) + +static bool js_cc_scene_Model_tetrahedronIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_tetrahedronIndex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_tetrahedronIndex_set) + +static bool js_cc_scene_Model_tetrahedronIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_tetrahedronIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_tetrahedronIndex_get) + +static bool js_cc_scene_Model_useLightProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_useLightProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_useLightProbe_set) + +static bool js_cc_scene_Model_useLightProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_useLightProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_useLightProbe_get) + +static bool js_cc_scene_Model_bakeToReflectionProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_bakeToReflectionProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_bakeToReflectionProbe_set) + +static bool js_cc_scene_Model_bakeToReflectionProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_bakeToReflectionProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_bakeToReflectionProbe_get) + +static bool js_cc_scene_Model_reflectionProbeType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::UseReflectionProbeType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_reflectionProbeType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeType_set) + +static bool js_cc_scene_Model_reflectionProbeType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::UseReflectionProbeType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::UseReflectionProbeType)cc_scene_Model_reflectionProbeType_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_scene_Model_reflectionProbeType_get) + +static bool js_cc_scene_Model_receiveDirLight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_receiveDirLight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_receiveDirLight_set) + +static bool js_cc_scene_Model_receiveDirLight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_receiveDirLight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_receiveDirLight_get) + +static bool js_cc_scene_Model_reflectionProbeId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_reflectionProbeId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeId_set) + +static bool js_cc_scene_Model_reflectionProbeId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_reflectionProbeId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_reflectionProbeId_get) + +static bool js_cc_scene_Model_reflectionProbeBlendId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_reflectionProbeBlendId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeBlendId_set) + +static bool js_cc_scene_Model_reflectionProbeBlendId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_reflectionProbeBlendId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_reflectionProbeBlendId_get) + +static bool js_cc_scene_Model_reflectionProbeBlendWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_reflectionProbeBlendWeight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeBlendWeight_set) + +static bool js_cc_scene_Model_reflectionProbeBlendWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Model_reflectionProbeBlendWeight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_reflectionProbeBlendWeight_get) + +bool js_register_cc_scene_Model(se::Object* obj) { + auto* cls = se::Class::create("Model", obj, nullptr, _SE(js_new_cc_scene_Model)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("scene", _SE(js_cc_scene_Model_scene_get), _SE(js_cc_scene_Model_scene_set)); + cls->defineProperty("_subModels", _SE(js_cc_scene_Model__subModels_get), nullptr); + cls->defineProperty("subModels", _SE(js_cc_scene_Model_subModels_get), nullptr); + cls->defineProperty("inited", _SE(js_cc_scene_Model_inited_get), nullptr); + cls->defineProperty("_localDataUpdated", _SE(js_cc_scene_Model__localDataUpdated_get), _SE(js_cc_scene_Model__localDataUpdated_set)); + cls->defineProperty("_worldBounds", _SE(js_cc_scene_Model__worldBounds_get), _SE(js_cc_scene_Model__worldBounds_set)); + cls->defineProperty("worldBounds", _SE(js_cc_scene_Model_worldBounds_get), _SE(js_cc_scene_Model_worldBounds_set)); + cls->defineProperty("_modelBounds", _SE(js_cc_scene_Model__modelBounds_get), _SE(js_cc_scene_Model__modelBounds_set)); + cls->defineProperty("modelBounds", _SE(js_cc_scene_Model_modelBounds_get), _SE(js_cc_scene_Model_modelBounds_set)); + cls->defineProperty("worldBoundBuffer", _SE(js_cc_scene_Model_worldBoundBuffer_get), _SE(js_cc_scene_Model_worldBoundBuffer_set)); + cls->defineProperty("localBuffer", _SE(js_cc_scene_Model_localBuffer_get), _SE(js_cc_scene_Model_localBuffer_set)); + cls->defineProperty("updateStamp", _SE(js_cc_scene_Model_updateStamp_get), nullptr); + cls->defineProperty("receiveShadow", _SE(js_cc_scene_Model_receiveShadow_get), _SE(js_cc_scene_Model_receiveShadow_set)); + cls->defineProperty("castShadow", _SE(js_cc_scene_Model_castShadow_get), _SE(js_cc_scene_Model_castShadow_set)); + cls->defineProperty("shadowBias", _SE(js_cc_scene_Model_shadowBias_get), _SE(js_cc_scene_Model_shadowBias_set)); + cls->defineProperty("shadowNormalBias", _SE(js_cc_scene_Model_shadowNormalBias_get), _SE(js_cc_scene_Model_shadowNormalBias_set)); + cls->defineProperty("node", _SE(js_cc_scene_Model_node_get), _SE(js_cc_scene_Model_node_set)); + cls->defineProperty("transform", _SE(js_cc_scene_Model_transform_get), _SE(js_cc_scene_Model_transform_set)); + cls->defineProperty("visFlags", _SE(js_cc_scene_Model_visFlags_get), _SE(js_cc_scene_Model_visFlags_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_Model_enabled_get), _SE(js_cc_scene_Model_enabled_set)); + cls->defineProperty("type", _SE(js_cc_scene_Model_type_get), _SE(js_cc_scene_Model_type_set)); + cls->defineProperty("isDynamicBatching", _SE(js_cc_scene_Model_isDynamicBatching_get), _SE(js_cc_scene_Model_isDynamicBatching_set)); + cls->defineProperty("priority", _SE(js_cc_scene_Model_priority_get), _SE(js_cc_scene_Model_priority_set)); + cls->defineProperty("tetrahedronIndex", _SE(js_cc_scene_Model_tetrahedronIndex_get), _SE(js_cc_scene_Model_tetrahedronIndex_set)); + cls->defineProperty("useLightProbe", _SE(js_cc_scene_Model_useLightProbe_get), _SE(js_cc_scene_Model_useLightProbe_set)); + cls->defineProperty("bakeToReflectionProbe", _SE(js_cc_scene_Model_bakeToReflectionProbe_get), _SE(js_cc_scene_Model_bakeToReflectionProbe_set)); + cls->defineProperty("reflectionProbeType", _SE(js_cc_scene_Model_reflectionProbeType_get), _SE(js_cc_scene_Model_reflectionProbeType_set)); + cls->defineProperty("receiveDirLight", _SE(js_cc_scene_Model_receiveDirLight_get), _SE(js_cc_scene_Model_receiveDirLight_set)); + cls->defineProperty("reflectionProbeId", _SE(js_cc_scene_Model_reflectionProbeId_get), _SE(js_cc_scene_Model_reflectionProbeId_set)); + cls->defineProperty("reflectionProbeBlendId", _SE(js_cc_scene_Model_reflectionProbeBlendId_get), _SE(js_cc_scene_Model_reflectionProbeBlendId_set)); + cls->defineProperty("reflectionProbeBlendWeight", _SE(js_cc_scene_Model_reflectionProbeBlendWeight_get), _SE(js_cc_scene_Model_reflectionProbeBlendWeight_set)); + + cls->defineFunction("destroy", _SE(js_cc_scene_Model_destroy)); + cls->defineFunction("initSubModel", _SE(js_cc_scene_Model_initSubModel)); + cls->defineFunction("getMacroPatches", _SE(js_cc_scene_Model_getMacroPatches)); + cls->defineFunction("setSubModelMaterial", _SE(js_cc_scene_Model_setSubModelMaterial)); + cls->defineFunction("_updateInstancedAttributes", _SE(js_cc_scene_Model__updateInstancedAttributes)); + cls->defineFunction("updateTransform", _SE(js_cc_scene_Model_updateTransform)); + cls->defineFunction("updateUBOs", _SE(js_cc_scene_Model_updateUBOs)); + cls->defineFunction("_updateLocalDescriptors", _SE(js_cc_scene_Model__updateLocalDescriptors)); + cls->defineFunction("_updateLocalSHDescriptors", _SE(js_cc_scene_Model__updateLocalSHDescriptors)); + cls->defineFunction("_updateWorldBoundDescriptors", _SE(js_cc_scene_Model__updateWorldBoundDescriptors)); + cls->defineFunction("createBoundingShape", _SE(js_cc_scene_Model_createBoundingShape)); + cls->defineFunction("initialize", _SE(js_cc_scene_Model_initialize)); + cls->defineFunction("initLightingmap", _SE(js_cc_scene_Model_initLightingmap)); + cls->defineFunction("_initLocalDescriptors", _SE(js_cc_scene_Model__initLocalDescriptors)); + cls->defineFunction("_initLocalSHDescriptors", _SE(js_cc_scene_Model__initLocalSHDescriptors)); + cls->defineFunction("initWorldBoundDescriptors", _SE(js_cc_scene_Model_initWorldBoundDescriptors)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_scene_Model_onGlobalPipelineStateChanged)); + cls->defineFunction("onMacroPatchesStateChanged", _SE(js_cc_scene_Model_onMacroPatchesStateChanged)); + cls->defineFunction("onGeometryChanged", _SE(js_cc_scene_Model_onGeometryChanged)); + cls->defineFunction("setSubModelMesh", _SE(js_cc_scene_Model_setSubModelMesh)); + cls->defineFunction("setInstancedAttribute", _SE(js_cc_scene_Model_setInstancedAttribute)); + cls->defineFunction("updateWorldBound", _SE(js_cc_scene_Model_updateWorldBound)); + cls->defineFunction("updateWorldBoundsForJSSkinningModel", _SE(js_cc_scene_Model_updateWorldBoundsForJSSkinningModel)); + cls->defineFunction("updateWorldBoundsForJSBakedSkinningModel", _SE(js_cc_scene_Model_updateWorldBoundsForJSBakedSkinningModel)); + cls->defineFunction("updateLightingmap", _SE(js_cc_scene_Model_updateLightingmap)); + cls->defineFunction("clearSHUBOs", _SE(js_cc_scene_Model_clearSHUBOs)); + cls->defineFunction("updateSHUBOs", _SE(js_cc_scene_Model_updateSHUBOs)); + cls->defineFunction("updateWorldBoundUBOs", _SE(js_cc_scene_Model_updateWorldBoundUBOs)); + cls->defineFunction("updateLocalShadowBias", _SE(js_cc_scene_Model_updateLocalShadowBias)); + cls->defineFunction("updateReflectionProbeCubemap", _SE(js_cc_scene_Model_updateReflectionProbeCubemap)); + cls->defineFunction("updateReflectionProbePlanarMap", _SE(js_cc_scene_Model_updateReflectionProbePlanarMap)); + cls->defineFunction("updateReflectionProbeId", _SE(js_cc_scene_Model_updateReflectionProbeId)); + cls->defineFunction("updateReflectionProbeDataMap", _SE(js_cc_scene_Model_updateReflectionProbeDataMap)); + cls->defineFunction("updateReflectionProbeBlendCubemap", _SE(js_cc_scene_Model_updateReflectionProbeBlendCubemap)); + cls->defineFunction("attachToScene", _SE(js_cc_scene_Model_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_Model_detachFromScene)); + cls->defineFunction("setLocalSHBuffer", _SE(js_cc_scene_Model_setLocalSHBuffer)); + cls->defineFunction("setBounds", _SE(js_cc_scene_Model_setBounds)); + cls->defineFunction("showTetrahedron", _SE(js_cc_scene_Model_showTetrahedron)); + cls->defineFunction("getLocalSHBuffer", _SE(js_cc_scene_Model_getLocalSHBuffer)); + cls->defineFunction("getLocalSHData", _SE(js_cc_scene_Model_getLocalSHData)); + cls->defineFunction("invalidateLocalData", _SE(js_cc_scene_Model_invalidateLocalData)); + cls->defineFunction("setCalledFromJS", _SE(js_cc_scene_Model_setCalledFromJS)); + cls->defineFunction("isModelImplementedInJS", _SE(js_cc_scene_Model_isModelImplementedInJS)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Model)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Model_proto = cls->getProto(); + __jsb_cc_scene_Model_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_InstancedAttributeBlock_class = nullptr; +se::Object* __jsb_cc_scene_InstancedAttributeBlock_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_InstancedAttributeBlock) + +static bool js_cc_scene_IInstancedAttributeBlock_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IInstancedAttributeBlock_buffer_set) + +static bool js_cc_scene_IInstancedAttributeBlock_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IInstancedAttributeBlock_buffer_get) + +static bool js_cc_scene_IInstancedAttributeBlock_views_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->views, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IInstancedAttributeBlock_views_set) + +static bool js_cc_scene_IInstancedAttributeBlock_views_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->views, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->views, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IInstancedAttributeBlock_views_get) + +static bool js_cc_scene_IInstancedAttributeBlock_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IInstancedAttributeBlock_attributes_set) + +static bool js_cc_scene_IInstancedAttributeBlock_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IInstancedAttributeBlock_attributes_get) + +static bool js_new_cc_scene_InstancedAttributeBlock(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::InstancedAttributeBlock *result; + result = (cc::scene::InstancedAttributeBlock *)new cc::scene::InstancedAttributeBlock(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_InstancedAttributeBlock, __jsb_cc_scene_InstancedAttributeBlock_class, js_delete_cc_scene_InstancedAttributeBlock) + +static bool js_delete_cc_scene_InstancedAttributeBlock(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_InstancedAttributeBlock) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::InstancedAttributeBlock * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + json->getProperty("views", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->views), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_InstancedAttributeBlock(se::Object* obj) { + auto* cls = se::Class::create("IInstancedAttributeBlock", obj, nullptr, _SE(js_new_cc_scene_InstancedAttributeBlock)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffer", _SE(js_cc_scene_IInstancedAttributeBlock_buffer_get), _SE(js_cc_scene_IInstancedAttributeBlock_buffer_set)); + cls->defineProperty("views", _SE(js_cc_scene_IInstancedAttributeBlock_views_get), _SE(js_cc_scene_IInstancedAttributeBlock_views_set)); + cls->defineProperty("attributes", _SE(js_cc_scene_IInstancedAttributeBlock_attributes_get), _SE(js_cc_scene_IInstancedAttributeBlock_attributes_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_InstancedAttributeBlock)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_InstancedAttributeBlock_proto = cls->getProto(); + __jsb_cc_scene_InstancedAttributeBlock_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SubModel_class = nullptr; +se::Object* __jsb_cc_scene_SubModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SubModel) + +static bool js_new_cc_scene_SubModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SubModel *result; + result = (cc::scene::SubModel *)new cc::scene::SubModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SubModel, __jsb_cc_scene_SubModel_class, js_delete_cc_scene_SubModel) + +static bool js_delete_cc_scene_SubModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SubModel) + +static bool js_cc_scene_SubModel_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_update) + +static bool js_cc_scene_SubModel_getShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + uint32_t arg2 ; + cc::gfx::Shader *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Shader *)((cc::scene::SubModel const *)arg1)->getShader(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_scene_SubModel_getShader) + +static bool js_cc_scene_SubModel_getPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + uint32_t arg2 ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::scene::Pass *)((cc::scene::SubModel const *)arg1)->getPass(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_scene_SubModel_getPass) + +static bool js_cc_scene_SubModel_setWorldBoundDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setWorldBoundDescriptorSet(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setWorldBoundDescriptorSet) + +static bool js_cc_scene_SubModel_setOwner(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOwner(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setOwner) + +static bool js_cc_scene_SubModel_setInstancedAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TypedArray *arg3 = 0 ; + ccstd::string temp2 ; + cc::TypedArray temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setInstancedAttribute((ccstd::string const &)*arg2,(cc::TypedArray const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setInstancedAttribute) + +static bool js_cc_scene_SubModel_getWorldBoundDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)((cc::scene::SubModel const *)arg1)->getWorldBoundDescriptorSet(); + + 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_scene_SubModel_getWorldBoundDescriptorSet) + +static bool js_cc_scene_SubModel_getOwner(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::Model *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)((cc::scene::SubModel const *)arg1)->getOwner(); + + 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_scene_SubModel_getOwner) + +static bool js_cc_scene_SubModel_getId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::SubModel const *)arg1)->getId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_getId) + +static bool js_cc_scene_SubModel_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::RenderingSubMesh *arg2 = (cc::RenderingSubMesh *) NULL ; + cc::scene::SharedPassArray *arg3 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > *arg4 = 0 ; + cc::scene::SharedPassArray temp3 ; + ccstd::vector< cc::scene::IMacroPatch > temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->initialize(arg2,(cc::scene::SharedPassArray const &)*arg3,(ccstd::vector< cc::scene::IMacroPatch > const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_initialize) + +static bool js_cc_scene_SubModel_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_destroy) + +static bool js_cc_scene_SubModel_onPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_onPipelineStateChanged) + +static bool js_cc_scene_SubModel_onMacroPatchesStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->onMacroPatchesStateChanged((ccstd::vector< cc::scene::IMacroPatch > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_onMacroPatchesStateChanged) + +static bool js_cc_scene_SubModel_onGeometryChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGeometryChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_onGeometryChanged) + +static bool js_cc_scene_SubModel_getReflectionProbeType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + int32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::SubModel const *)arg1)->getReflectionProbeType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_getReflectionProbeType) + +static bool js_cc_scene_SubModel_setReflectionProbeType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + int32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setReflectionProbeType(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setReflectionProbeType) + +static bool js_cc_scene_SubModel_passes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::SharedPassArray *arg2 = 0 ; + cc::scene::SharedPassArray temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SubModel_passes_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_passes_set) + +static bool js_cc_scene_SubModel_passes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::SharedPassArray *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::SharedPassArray *) &cc_scene_SubModel_passes_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_scene_SubModel_passes_get) + +static bool js_cc_scene_SubModel_shaders_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SubModel_shaders_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_shaders_set) + +static bool js_cc_scene_SubModel_shaders_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > *) &cc_scene_SubModel_shaders_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_scene_SubModel_shaders_get) + +static bool js_cc_scene_SubModel_subMesh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::RenderingSubMesh *arg2 = (cc::RenderingSubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SubModel_subMesh_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_subMesh_set) + +static bool js_cc_scene_SubModel_subMesh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::RenderingSubMesh *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::RenderingSubMesh *)cc_scene_SubModel_subMesh_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_scene_SubModel_subMesh_get) + +static bool js_cc_scene_SubModel_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::pipeline::RenderPriority arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_SubModel_priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_priority_set) + +static bool js_cc_scene_SubModel_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::pipeline::RenderPriority result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_SubModel_priority_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_scene_SubModel_priority_get) + +static bool js_cc_scene_SubModel_inputAssembler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::InputAssembler *arg2 = (cc::gfx::InputAssembler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SubModel_inputAssembler_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_inputAssembler_set) + +static bool js_cc_scene_SubModel_inputAssembler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::InputAssembler *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssembler *)cc_scene_SubModel_inputAssembler_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_scene_SubModel_inputAssembler_get) + +static bool js_cc_scene_SubModel_descriptorSet_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SubModel_descriptorSet_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_descriptorSet_set) + +static bool js_cc_scene_SubModel_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)cc_scene_SubModel_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_scene_SubModel_descriptorSet_get) + +static bool js_cc_scene_SubModel_patches_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::scene::IMacroPatch > *) &cc_scene_SubModel_patches_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_scene_SubModel_patches_get) + +bool js_register_cc_scene_SubModel(se::Object* obj) { + auto* cls = se::Class::create("SubModel", obj, nullptr, _SE(js_new_cc_scene_SubModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("passes", _SE(js_cc_scene_SubModel_passes_get), _SE(js_cc_scene_SubModel_passes_set)); + cls->defineProperty("shaders", _SE(js_cc_scene_SubModel_shaders_get), _SE(js_cc_scene_SubModel_shaders_set)); + cls->defineProperty("subMesh", _SE(js_cc_scene_SubModel_subMesh_get), _SE(js_cc_scene_SubModel_subMesh_set)); + cls->defineProperty("priority", _SE(js_cc_scene_SubModel_priority_get), _SE(js_cc_scene_SubModel_priority_set)); + cls->defineProperty("inputAssembler", _SE(js_cc_scene_SubModel_inputAssembler_get), _SE(js_cc_scene_SubModel_inputAssembler_set)); + cls->defineProperty("descriptorSet", _SE(js_cc_scene_SubModel_descriptorSet_get), _SE(js_cc_scene_SubModel_descriptorSet_set)); + cls->defineProperty("patches", _SE(js_cc_scene_SubModel_patches_get), nullptr); + + cls->defineFunction("update", _SE(js_cc_scene_SubModel_update)); + cls->defineFunction("getShader", _SE(js_cc_scene_SubModel_getShader)); + cls->defineFunction("getPass", _SE(js_cc_scene_SubModel_getPass)); + cls->defineFunction("setWorldBoundDescriptorSet", _SE(js_cc_scene_SubModel_setWorldBoundDescriptorSet)); + cls->defineFunction("setOwner", _SE(js_cc_scene_SubModel_setOwner)); + cls->defineFunction("setInstancedAttribute", _SE(js_cc_scene_SubModel_setInstancedAttribute)); + cls->defineFunction("getWorldBoundDescriptorSet", _SE(js_cc_scene_SubModel_getWorldBoundDescriptorSet)); + cls->defineFunction("getOwner", _SE(js_cc_scene_SubModel_getOwner)); + cls->defineFunction("getId", _SE(js_cc_scene_SubModel_getId)); + cls->defineFunction("initialize", _SE(js_cc_scene_SubModel_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_SubModel_destroy)); + cls->defineFunction("onPipelineStateChanged", _SE(js_cc_scene_SubModel_onPipelineStateChanged)); + cls->defineFunction("onMacroPatchesStateChanged", _SE(js_cc_scene_SubModel_onMacroPatchesStateChanged)); + cls->defineFunction("onGeometryChanged", _SE(js_cc_scene_SubModel_onGeometryChanged)); + cls->defineFunction("getReflectionProbeType", _SE(js_cc_scene_SubModel_getReflectionProbeType)); + cls->defineFunction("setReflectionProbeType", _SE(js_cc_scene_SubModel_setReflectionProbeType)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SubModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SubModel_proto = cls->getProto(); + __jsb_cc_scene_SubModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PassDynamicsValue_class = nullptr; +se::Object* __jsb_cc_scene_PassDynamicsValue_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PassDynamicsValue) + +static bool js_cc_scene_PassDynamicsValue_dirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PassDynamicsValue_dirty_set) + +static bool js_cc_scene_PassDynamicsValue_dirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PassDynamicsValue_dirty_get) + +static bool js_cc_scene_PassDynamicsValue_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PassDynamicsValue_value_set) + +static bool js_cc_scene_PassDynamicsValue_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PassDynamicsValue_value_get) + +static bool js_new_cc_scene_PassDynamicsValue(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PassDynamicsValue *result; + result = (cc::scene::PassDynamicsValue *)new cc::scene::PassDynamicsValue(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PassDynamicsValue, __jsb_cc_scene_PassDynamicsValue_class, js_delete_cc_scene_PassDynamicsValue) + +static bool js_delete_cc_scene_PassDynamicsValue(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PassDynamicsValue) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::PassDynamicsValue * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("dirty", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dirty), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_PassDynamicsValue(se::Object* obj) { + auto* cls = se::Class::create("PassDynamicsValue", obj, nullptr, _SE(js_new_cc_scene_PassDynamicsValue)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dirty", _SE(js_cc_scene_PassDynamicsValue_dirty_get), _SE(js_cc_scene_PassDynamicsValue_dirty_set)); + cls->defineProperty("value", _SE(js_cc_scene_PassDynamicsValue_value_get), _SE(js_cc_scene_PassDynamicsValue_value_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PassDynamicsValue)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PassDynamicsValue_proto = cls->getProto(); + __jsb_cc_scene_PassDynamicsValue_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IBlockRef_class = nullptr; +se::Object* __jsb_cc_scene_IBlockRef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IBlockRef) + +static bool js_cc_scene_IBlockRef_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IBlockRef_data_set) + +static bool js_cc_scene_IBlockRef_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IBlockRef_data_get) + +static bool js_cc_scene_IBlockRef_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IBlockRef_count_set) + +static bool js_cc_scene_IBlockRef_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IBlockRef_count_get) + +static bool js_cc_scene_IBlockRef_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IBlockRef_offset_set) + +static bool js_cc_scene_IBlockRef_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IBlockRef_offset_get) + +static bool js_new_cc_scene_IBlockRef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IBlockRef *result; + result = (cc::scene::IBlockRef *)new cc::scene::IBlockRef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IBlockRef, __jsb_cc_scene_IBlockRef_class, js_delete_cc_scene_IBlockRef) + +static bool js_delete_cc_scene_IBlockRef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IBlockRef) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IBlockRef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("data", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->data), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IBlockRef(se::Object* obj) { + auto* cls = se::Class::create("IBlockRef", obj, nullptr, _SE(js_new_cc_scene_IBlockRef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_cc_scene_IBlockRef_data_get), _SE(js_cc_scene_IBlockRef_data_set)); + cls->defineProperty("count", _SE(js_cc_scene_IBlockRef_count_get), _SE(js_cc_scene_IBlockRef_count_set)); + cls->defineProperty("offset", _SE(js_cc_scene_IBlockRef_offset_get), _SE(js_cc_scene_IBlockRef_offset_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IBlockRef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IBlockRef_proto = cls->getProto(); + __jsb_cc_scene_IBlockRef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Pass_class = nullptr; +se::Object* __jsb_cc_scene_Pass_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Pass) + +static bool js_cc_scene_Pass_getTypeFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + cc::gfx::Type result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getTypeFromHandle(SWIG_STD_MOVE(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_FUNC(js_cc_scene_Pass_getTypeFromHandle_static) + +static bool js_cc_scene_Pass_getBindingFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getBindingFromHandle(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getBindingFromHandle_static) + +static bool js_cc_scene_Pass_getCountFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getCountFromHandle(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getCountFromHandle_static) + +static bool js_cc_scene_Pass_getOffsetFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getOffsetFromHandle(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getOffsetFromHandle_static) + +static bool js_cc_scene_Pass_fillPipelineInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfoFull *arg2 = 0 ; + cc::IPassInfoFull temp2 ; + + 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; + + cc::scene::Pass::fillPipelineInfo(arg1,(cc::IPassInfoFull const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_fillPipelineInfo_static) + +static bool js_cc_scene_Pass_getPassHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::scene::Pass::getPassHash(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_FUNC(js_cc_scene_Pass_getPassHash_static) + +static bool js_new_cc_scene_Pass__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::scene::Pass *result; + result = (cc::scene::Pass *)new cc::scene::Pass(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_Pass__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Pass *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::Pass *)new cc::scene::Pass(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_Pass(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_scene_Pass__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_scene_Pass__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Pass"); + return false; +} +SE_BIND_CTOR(js_new_cc_scene_Pass, __jsb_cc_scene_Pass_class, js_delete_cc_scene_Pass) + +static bool js_delete_cc_scene_Pass(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Pass) + +static bool js_cc_scene_Pass_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfoFull *arg2 = 0 ; + cc::IPassInfoFull temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::IPassInfoFull const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_initialize) + +static bool js_cc_scene_Pass_getHandle__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + cc::gfx::Type arg4 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::scene::Pass const *)arg1)->getHandle((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_getHandle__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(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 = ((cc::scene::Pass const *)arg1)->getHandle((ccstd::string const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_getHandle__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(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::scene::Pass const *)arg1)->getHandle((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_getHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_Pass_getHandle__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_getHandle__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_Pass_getHandle__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_getHandle) + +static bool js_cc_scene_Pass_getBinding(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) 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(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::scene::Pass const *)arg1)->getBinding((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getBinding) + +static bool js_cc_scene_Pass_setUniform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::MaterialProperty *arg3 = 0 ; + cc::MaterialProperty temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setUniform(arg2,(cc::MaterialProperty const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setUniform) + +static bool js_cc_scene_Pass__getUniform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::MaterialProperty result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::scene::Pass const *)arg1)->getUniform(arg2); + + ccstd::visit( + [&](auto ¶m) { + using ParamType = std::remove_reference_t; + if constexpr (std::is_same_v || std::is_same_v) { + ok = nativevalue_to_se(param, s.rval()); + } else { + auto *temp = ccnew ParamType(param); + ok = nativevalue_to_se(temp, s.rval()); + if (ok) { + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + } else { + s.rval().setUndefined(); + delete temp; + } + } + }, + result); + + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass__getUniform) + +static bool js_cc_scene_Pass_setUniformArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::MaterialPropertyList *arg3 = 0 ; + cc::MaterialPropertyList temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setUniformArray(arg2,(cc::MaterialPropertyList const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setUniformArray) + +static bool js_cc_scene_Pass_bindTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_scene_Pass_bindTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3); + + + return true; +} + +static bool js_cc_scene_Pass_bindTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_Pass_bindTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_bindTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_bindTexture) + +static bool js_cc_scene_Pass_bindSampler__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_scene_Pass_bindSampler__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3); + + + return true; +} + +static bool js_cc_scene_Pass_bindSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_Pass_bindSampler__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_bindSampler__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_bindSampler) + +static bool js_cc_scene_Pass_setDynamicState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DynamicStateFlagBit arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDynamicState(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setDynamicState) + +static bool js_cc_scene_Pass_overridePipelineStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfo *arg2 = 0 ; + cc::PassOverrides *arg3 = 0 ; + cc::IPassInfo temp2 ; + cc::PassOverrides temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::IPassInfo const &)*arg2,(cc::PassOverrides const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_overridePipelineStates) + +static bool js_cc_scene_Pass_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_update) + +static bool js_cc_scene_Pass_getInstancedBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + int32_t arg2 ; + cc::pipeline::InstancedBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::pipeline::InstancedBuffer *)(arg1)->getInstancedBuffer(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_scene_Pass_getInstancedBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::InstancedBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::InstancedBuffer *)(arg1)->getInstancedBuffer(); + + 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_scene_Pass_getInstancedBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_Pass_getInstancedBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_scene_Pass_getInstancedBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_getInstancedBuffer) + +static bool js_cc_scene_Pass_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_destroy) + +static bool js_cc_scene_Pass_resetUniform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resetUniform((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetUniform) + +static bool js_cc_scene_Pass_resetTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->resetTexture((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_scene_Pass_resetTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->resetTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_scene_Pass_resetTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_Pass_resetTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_resetTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetTexture) + +static bool js_cc_scene_Pass_resetUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetUBOs) + +static bool js_cc_scene_Pass_resetTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetTextures(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetTextures) + +static bool js_cc_scene_Pass_tryCompile__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->tryCompile(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_tryCompile__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::optional< cc::MacroRecord > *arg2 = 0 ; + ccstd::optional< cc::MacroRecord > temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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)(arg1)->tryCompile((ccstd::optional< cc::MacroRecord > const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_tryCompile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_scene_Pass_tryCompile__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_Pass_tryCompile__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_tryCompile) + +static bool js_cc_scene_Pass_getShaderVariant__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)(arg1)->getShaderVariant(); + + 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_scene_Pass_getShaderVariant__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Shader *)(arg1)->getShaderVariant((ccstd::vector< cc::scene::IMacroPatch > 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; +} + +static bool js_cc_scene_Pass_getShaderVariant(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_scene_Pass_getShaderVariant__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_Pass_getShaderVariant__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_getShaderVariant) + +static bool js_cc_scene_Pass_getPassInfoFull(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfoFull result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Pass const *)arg1)->getPassInfoFull(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getPassInfoFull) + +static bool js_cc_scene_Pass_getRootBlock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::ArrayBuffer *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(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)(arg1)->getRootBlock(); + + 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_scene_Pass_getRootBlock) + +static bool js_cc_scene_Pass_setRootBufferDirty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRootBufferDirty(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setRootBufferDirty) + +static bool js_cc_scene_Pass_setPriority(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::RenderPriority arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setPriority(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setPriority) + +static bool js_cc_scene_Pass_getPassID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Pass const *)arg1)->getPassID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getPassID) + +static bool js_cc_scene_Pass_getSubpassOrPassID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Pass const *)arg1)->getSubpassOrPassID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getSubpassOrPassID) + +static bool js_cc_scene_Pass__updatePassHash(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updatePassHash(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass__updatePassHash) + +static bool js_cc_scene_Pass_beginChangeStatesSilently(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginChangeStatesSilently(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_beginChangeStatesSilently) + +static bool js_cc_scene_Pass_endChangeStatesSilently(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endChangeStatesSilently(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_endChangeStatesSilently) + +static bool js_cc_scene_Pass_root_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::Root *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Root *)cc_scene_Pass_root_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_scene_Pass_root_get) + +static bool js_cc_scene_Pass_device_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::Device *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)cc_scene_Pass_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_scene_Pass_device_get) + +static bool js_cc_scene_Pass_shaderInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IProgramInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::IProgramInfo *)cc_scene_Pass_shaderInfo_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_scene_Pass_shaderInfo_get) + +static bool js_cc_scene_Pass_localSetLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)cc_scene_Pass_localSetLayout_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_scene_Pass_localSetLayout_get) + +static bool js_cc_scene_Pass_program_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_Pass_program_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_scene_Pass_program_get) + +static bool js_cc_scene_Pass_properties_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::PassPropertyInfoMap *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::PassPropertyInfoMap *) &cc_scene_Pass_properties_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_scene_Pass_properties_get) + +static bool js_cc_scene_Pass_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::MacroRecord *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::MacroRecord *) &cc_scene_Pass_defines_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_scene_Pass_defines_get) + +static bool js_cc_scene_Pass_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + index_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_passIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_passIndex_get) + +static bool js_cc_scene_Pass_propertyIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + index_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_propertyIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_propertyIndex_get) + +static bool js_cc_scene_Pass_dynamics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::scene::IPassDynamics *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::IPassDynamics *) &cc_scene_Pass_dynamics_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_scene_Pass_dynamics_get) + +static bool js_cc_scene_Pass_rootBufferDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Pass_rootBufferDirty_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_rootBufferDirty_get) + +static bool js_cc_scene_Pass_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::RenderPriority result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_priority_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_scene_Pass_priority_get) + +static bool js_cc_scene_Pass_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::PrimitiveMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_primitive_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_scene_Pass_primitive_get) + +static bool js_cc_scene_Pass_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::RenderPassStage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_stage_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_scene_Pass_stage_get) + +static bool js_cc_scene_Pass_phase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_phase_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_phase_get) + +static bool js_cc_scene_Pass_phaseID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_phaseID_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_phaseID_get) + +static bool js_cc_scene_Pass_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::RasterizerState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RasterizerState *)cc_scene_Pass_rasterizerState_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_scene_Pass_rasterizerState_get) + +static bool js_cc_scene_Pass_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DepthStencilState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilState *)cc_scene_Pass_depthStencilState_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_scene_Pass_depthStencilState_get) + +static bool js_cc_scene_Pass_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::BlendState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BlendState *)cc_scene_Pass_blendState_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_scene_Pass_blendState_get) + +static bool js_cc_scene_Pass_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DynamicStateFlagBit result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_dynamicStates_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_scene_Pass_dynamicStates_get) + +static bool js_cc_scene_Pass_batchingScheme_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::scene::BatchingSchemes result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::BatchingSchemes)cc_scene_Pass_batchingScheme_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_scene_Pass_batchingScheme_get) + +static bool js_cc_scene_Pass_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DescriptorSet *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)cc_scene_Pass_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_scene_Pass_descriptorSet_get) + +static bool js_cc_scene_Pass_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_hash_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_scene_Pass_hash_get) + +static bool js_cc_scene_Pass_pipelineLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::PipelineLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PipelineLayout *)cc_scene_Pass_pipelineLayout_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_scene_Pass_pipelineLayout_get) + +bool js_register_cc_scene_Pass(se::Object* obj) { + auto* cls = se::Class::create("Pass", obj, nullptr, _SE(js_new_cc_scene_Pass)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("root", _SE(js_cc_scene_Pass_root_get), nullptr); + cls->defineProperty("device", _SE(js_cc_scene_Pass_device_get), nullptr); + cls->defineProperty("shaderInfo", _SE(js_cc_scene_Pass_shaderInfo_get), nullptr); + cls->defineProperty("localSetLayout", _SE(js_cc_scene_Pass_localSetLayout_get), nullptr); + cls->defineProperty("program", _SE(js_cc_scene_Pass_program_get), nullptr); + cls->defineProperty("properties", _SE(js_cc_scene_Pass_properties_get), nullptr); + cls->defineProperty("defines", _SE(js_cc_scene_Pass_defines_get), nullptr); + cls->defineProperty("passIndex", _SE(js_cc_scene_Pass_passIndex_get), nullptr); + cls->defineProperty("propertyIndex", _SE(js_cc_scene_Pass_propertyIndex_get), nullptr); + cls->defineProperty("dynamics", _SE(js_cc_scene_Pass_dynamics_get), nullptr); + cls->defineProperty("rootBufferDirty", _SE(js_cc_scene_Pass_rootBufferDirty_get), nullptr); + cls->defineProperty("priority", _SE(js_cc_scene_Pass_priority_get), nullptr); + cls->defineProperty("primitive", _SE(js_cc_scene_Pass_primitive_get), nullptr); + cls->defineProperty("stage", _SE(js_cc_scene_Pass_stage_get), nullptr); + cls->defineProperty("phase", _SE(js_cc_scene_Pass_phase_get), nullptr); + cls->defineProperty("phaseID", _SE(js_cc_scene_Pass_phaseID_get), nullptr); + cls->defineProperty("rasterizerState", _SE(js_cc_scene_Pass_rasterizerState_get), nullptr); + cls->defineProperty("depthStencilState", _SE(js_cc_scene_Pass_depthStencilState_get), nullptr); + cls->defineProperty("blendState", _SE(js_cc_scene_Pass_blendState_get), nullptr); + cls->defineProperty("dynamicStates", _SE(js_cc_scene_Pass_dynamicStates_get), nullptr); + cls->defineProperty("batchingScheme", _SE(js_cc_scene_Pass_batchingScheme_get), nullptr); + cls->defineProperty("descriptorSet", _SE(js_cc_scene_Pass_descriptorSet_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_scene_Pass_hash_get), nullptr); + cls->defineProperty("pipelineLayout", _SE(js_cc_scene_Pass_pipelineLayout_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Pass_initialize)); + cls->defineFunction("getHandle", _SE(js_cc_scene_Pass_getHandle)); + cls->defineFunction("getBinding", _SE(js_cc_scene_Pass_getBinding)); + cls->defineFunction("setUniform", _SE(js_cc_scene_Pass_setUniform)); + cls->defineFunction("_getUniform", _SE(js_cc_scene_Pass__getUniform)); + cls->defineFunction("setUniformArray", _SE(js_cc_scene_Pass_setUniformArray)); + cls->defineFunction("bindTexture", _SE(js_cc_scene_Pass_bindTexture)); + cls->defineFunction("bindSampler", _SE(js_cc_scene_Pass_bindSampler)); + cls->defineFunction("setDynamicState", _SE(js_cc_scene_Pass_setDynamicState)); + cls->defineFunction("overridePipelineStates", _SE(js_cc_scene_Pass_overridePipelineStates)); + cls->defineFunction("update", _SE(js_cc_scene_Pass_update)); + cls->defineFunction("getInstancedBuffer", _SE(js_cc_scene_Pass_getInstancedBuffer)); + cls->defineFunction("destroy", _SE(js_cc_scene_Pass_destroy)); + cls->defineFunction("resetUniform", _SE(js_cc_scene_Pass_resetUniform)); + cls->defineFunction("resetTexture", _SE(js_cc_scene_Pass_resetTexture)); + cls->defineFunction("resetUBOs", _SE(js_cc_scene_Pass_resetUBOs)); + cls->defineFunction("resetTextures", _SE(js_cc_scene_Pass_resetTextures)); + cls->defineFunction("tryCompile", _SE(js_cc_scene_Pass_tryCompile)); + cls->defineFunction("getShaderVariant", _SE(js_cc_scene_Pass_getShaderVariant)); + cls->defineFunction("getPassInfoFull", _SE(js_cc_scene_Pass_getPassInfoFull)); + cls->defineFunction("getRootBlock", _SE(js_cc_scene_Pass_getRootBlock)); + cls->defineFunction("setRootBufferDirty", _SE(js_cc_scene_Pass_setRootBufferDirty)); + cls->defineFunction("setPriority", _SE(js_cc_scene_Pass_setPriority)); + cls->defineFunction("getPassID", _SE(js_cc_scene_Pass_getPassID)); + cls->defineFunction("getSubpassOrPassID", _SE(js_cc_scene_Pass_getSubpassOrPassID)); + cls->defineFunction("_updatePassHash", _SE(js_cc_scene_Pass__updatePassHash)); + cls->defineFunction("beginChangeStatesSilently", _SE(js_cc_scene_Pass_beginChangeStatesSilently)); + cls->defineFunction("endChangeStatesSilently", _SE(js_cc_scene_Pass_endChangeStatesSilently)); + + + cls->defineStaticFunction("getTypeFromHandle", _SE(js_cc_scene_Pass_getTypeFromHandle_static)); + cls->defineStaticFunction("getBindingFromHandle", _SE(js_cc_scene_Pass_getBindingFromHandle_static)); + cls->defineStaticFunction("getCountFromHandle", _SE(js_cc_scene_Pass_getCountFromHandle_static)); + cls->defineStaticFunction("getOffsetFromHandle", _SE(js_cc_scene_Pass_getOffsetFromHandle_static)); + cls->defineStaticFunction("fillPipelineInfo", _SE(js_cc_scene_Pass_fillPipelineInfo_static)); + cls->defineStaticFunction("getPassHash", _SE(js_cc_scene_Pass_getPassHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Pass)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Pass_proto = cls->getProto(); + __jsb_cc_scene_Pass_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IRaycastResult_class = nullptr; +se::Object* __jsb_cc_scene_IRaycastResult_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IRaycastResult) + +static bool js_cc_scene_IRaycastResult_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->node, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRaycastResult_node_set) + +static bool js_cc_scene_IRaycastResult_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->node, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->node, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRaycastResult_node_get) + +static bool js_cc_scene_IRaycastResult_distance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->distance, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRaycastResult_distance_set) + +static bool js_cc_scene_IRaycastResult_distance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->distance, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRaycastResult_distance_get) + +static bool js_new_cc_scene_IRaycastResult(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IRaycastResult *result; + result = (cc::scene::IRaycastResult *)new cc::scene::IRaycastResult(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IRaycastResult, __jsb_cc_scene_IRaycastResult_class, js_delete_cc_scene_IRaycastResult) + +static bool js_delete_cc_scene_IRaycastResult(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IRaycastResult) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRaycastResult * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("node", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->node), ctx); + } + + + json->getProperty("distance", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->distance), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IRaycastResult(se::Object* obj) { + auto* cls = se::Class::create("IRaycastResult", obj, nullptr, _SE(js_new_cc_scene_IRaycastResult)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("node", _SE(js_cc_scene_IRaycastResult_node_get), _SE(js_cc_scene_IRaycastResult_node_set)); + cls->defineProperty("distance", _SE(js_cc_scene_IRaycastResult_distance_get), _SE(js_cc_scene_IRaycastResult_distance_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IRaycastResult)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IRaycastResult_proto = cls->getProto(); + __jsb_cc_scene_IRaycastResult_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IRenderSceneInfo_class = nullptr; +se::Object* __jsb_cc_scene_IRenderSceneInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IRenderSceneInfo) + +static bool js_cc_scene_IRenderSceneInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderSceneInfo *arg1 = (cc::scene::IRenderSceneInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderSceneInfo_name_set) + +static bool js_cc_scene_IRenderSceneInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderSceneInfo *arg1 = (cc::scene::IRenderSceneInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderSceneInfo_name_get) + +static bool js_new_cc_scene_IRenderSceneInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IRenderSceneInfo *result; + result = (cc::scene::IRenderSceneInfo *)new cc::scene::IRenderSceneInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IRenderSceneInfo, __jsb_cc_scene_IRenderSceneInfo_class, js_delete_cc_scene_IRenderSceneInfo) + +static bool js_delete_cc_scene_IRenderSceneInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IRenderSceneInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderSceneInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IRenderSceneInfo(se::Object* obj) { + auto* cls = se::Class::create("IRenderSceneInfo", obj, nullptr, _SE(js_new_cc_scene_IRenderSceneInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_IRenderSceneInfo_name_get), _SE(js_cc_scene_IRenderSceneInfo_name_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IRenderSceneInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IRenderSceneInfo_proto = cls->getProto(); + __jsb_cc_scene_IRenderSceneInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_RenderScene_class = nullptr; +se::Object* __jsb_cc_scene_RenderScene_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_RenderScene) + +static bool js_new_cc_scene_RenderScene(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::RenderScene *result; + result = (cc::scene::RenderScene *)new cc::scene::RenderScene(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_RenderScene, __jsb_cc_scene_RenderScene_class, js_delete_cc_scene_RenderScene) + +static bool js_delete_cc_scene_RenderScene(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_RenderScene) + +static bool js_cc_scene_RenderScene_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::IRenderSceneInfo *arg2 = 0 ; + cc::scene::IRenderSceneInfo 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(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)(arg1)->initialize((cc::scene::IRenderSceneInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_initialize) + +static bool js_cc_scene_RenderScene_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_update) + +static bool js_cc_scene_RenderScene_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_destroy) + +static bool js_cc_scene_RenderScene_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_activate) + +static bool js_cc_scene_RenderScene_addCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addCamera) + +static bool js_cc_scene_RenderScene_removeCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeCamera) + +static bool js_cc_scene_RenderScene_removeCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeCameras(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeCameras) + +static bool js_cc_scene_RenderScene_addLODGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::LODGroup *arg2 = (cc::scene::LODGroup *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addLODGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addLODGroup) + +static bool js_cc_scene_RenderScene_removeLODGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::LODGroup *arg2 = (cc::scene::LODGroup *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeLODGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeLODGroup) + +static bool js_cc_scene_RenderScene_isCulledByLod(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::Model *arg3 = (cc::scene::Model *) NULL ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((cc::scene::RenderScene const *)arg1)->isCulledByLod((cc::scene::Camera const *)arg2,(cc::scene::Model const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_isCulledByLod) + +static bool js_cc_scene_RenderScene_unsetMainLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->unsetMainLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_unsetMainLight) + +static bool js_cc_scene_RenderScene_addDirectionalLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDirectionalLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addDirectionalLight) + +static bool js_cc_scene_RenderScene_removeDirectionalLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeDirectionalLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeDirectionalLight) + +static bool js_cc_scene_RenderScene_addSphereLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphereLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addSphereLight) + +static bool js_cc_scene_RenderScene_removeSphereLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeSphereLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSphereLight) + +static bool js_cc_scene_RenderScene_removeSphereLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeSphereLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSphereLights) + +static bool js_cc_scene_RenderScene_addSpotLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSpotLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addSpotLight) + +static bool js_cc_scene_RenderScene_removeSpotLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeSpotLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSpotLight) + +static bool js_cc_scene_RenderScene_removeSpotLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeSpotLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSpotLights) + +static bool js_cc_scene_RenderScene_addPointLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPointLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addPointLight) + +static bool js_cc_scene_RenderScene_removePointLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removePointLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removePointLight) + +static bool js_cc_scene_RenderScene_removePointLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removePointLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removePointLights) + +static bool js_cc_scene_RenderScene_addRangedDirLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addRangedDirLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addRangedDirLight) + +static bool js_cc_scene_RenderScene_removeRangedDirLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeRangedDirLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeRangedDirLight) + +static bool js_cc_scene_RenderScene_removeRangedDirLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeRangedDirLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeRangedDirLights) + +static bool js_cc_scene_RenderScene_addModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addModel) + +static bool js_cc_scene_RenderScene_removeModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeModel) + +static bool js_cc_scene_RenderScene_removeModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeModels) + +static bool js_cc_scene_RenderScene_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_onGlobalPipelineStateChanged) + +static bool js_cc_scene_RenderScene_getMainLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::DirectionalLight *)((cc::scene::RenderScene const *)arg1)->getMainLight(); + + 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_scene_RenderScene_getMainLight) + +static bool js_cc_scene_RenderScene_setMainLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMainLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_setMainLight) + +static bool js_cc_scene_RenderScene_generateModelId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + uint64_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->generateModelId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_generateModelId) + +static bool js_cc_scene_RenderScene_getOctree(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Octree *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Octree *)((cc::scene::RenderScene const *)arg1)->getOctree(); + + 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_scene_RenderScene_getOctree) + +static bool js_cc_scene_RenderScene_updateOctree(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateOctree(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_updateOctree) + +static bool js_cc_scene_RenderScene_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_RenderScene_name_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_scene_RenderScene_name_get) + +static bool js_cc_scene_RenderScene_cameras_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *) &cc_scene_RenderScene_cameras_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_scene_RenderScene_cameras_get) + +static bool js_cc_scene_RenderScene_sphereLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SphereLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SphereLight > > *) &cc_scene_RenderScene_sphereLights_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_scene_RenderScene_sphereLights_get) + +static bool js_cc_scene_RenderScene_spotLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SpotLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SpotLight > > *) &cc_scene_RenderScene_spotLights_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_scene_RenderScene_spotLights_get) + +static bool js_cc_scene_RenderScene_pointLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::PointLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::PointLight > > *) &cc_scene_RenderScene_pointLights_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_scene_RenderScene_pointLights_get) + +static bool js_cc_scene_RenderScene_rangedDirLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::RangedDirectionalLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::RangedDirectionalLight > > *) &cc_scene_RenderScene_rangedDirLights_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_scene_RenderScene_rangedDirLights_get) + +static bool js_cc_scene_RenderScene_models_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *) &cc_scene_RenderScene_models_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_scene_RenderScene_models_get) + +static bool js_cc_scene_RenderScene_lodGroups_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::LODGroup > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::LODGroup > > *) &cc_scene_RenderScene_lodGroups_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_scene_RenderScene_lodGroups_get) + +bool js_register_cc_scene_RenderScene(se::Object* obj) { + auto* cls = se::Class::create("RenderScene", obj, nullptr, _SE(js_new_cc_scene_RenderScene)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_RenderScene_name_get), nullptr); + cls->defineProperty("cameras", _SE(js_cc_scene_RenderScene_cameras_get), nullptr); + cls->defineProperty("sphereLights", _SE(js_cc_scene_RenderScene_sphereLights_get), nullptr); + cls->defineProperty("spotLights", _SE(js_cc_scene_RenderScene_spotLights_get), nullptr); + cls->defineProperty("pointLights", _SE(js_cc_scene_RenderScene_pointLights_get), nullptr); + cls->defineProperty("rangedDirLights", _SE(js_cc_scene_RenderScene_rangedDirLights_get), nullptr); + cls->defineProperty("models", _SE(js_cc_scene_RenderScene_models_get), nullptr); + cls->defineProperty("lodGroups", _SE(js_cc_scene_RenderScene_lodGroups_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_RenderScene_initialize)); + cls->defineFunction("update", _SE(js_cc_scene_RenderScene_update)); + cls->defineFunction("destroy", _SE(js_cc_scene_RenderScene_destroy)); + cls->defineFunction("activate", _SE(js_cc_scene_RenderScene_activate)); + cls->defineFunction("addCamera", _SE(js_cc_scene_RenderScene_addCamera)); + cls->defineFunction("removeCamera", _SE(js_cc_scene_RenderScene_removeCamera)); + cls->defineFunction("removeCameras", _SE(js_cc_scene_RenderScene_removeCameras)); + cls->defineFunction("addLODGroup", _SE(js_cc_scene_RenderScene_addLODGroup)); + cls->defineFunction("removeLODGroup", _SE(js_cc_scene_RenderScene_removeLODGroup)); + cls->defineFunction("isCulledByLod", _SE(js_cc_scene_RenderScene_isCulledByLod)); + cls->defineFunction("unsetMainLight", _SE(js_cc_scene_RenderScene_unsetMainLight)); + cls->defineFunction("addDirectionalLight", _SE(js_cc_scene_RenderScene_addDirectionalLight)); + cls->defineFunction("removeDirectionalLight", _SE(js_cc_scene_RenderScene_removeDirectionalLight)); + cls->defineFunction("addSphereLight", _SE(js_cc_scene_RenderScene_addSphereLight)); + cls->defineFunction("removeSphereLight", _SE(js_cc_scene_RenderScene_removeSphereLight)); + cls->defineFunction("removeSphereLights", _SE(js_cc_scene_RenderScene_removeSphereLights)); + cls->defineFunction("addSpotLight", _SE(js_cc_scene_RenderScene_addSpotLight)); + cls->defineFunction("removeSpotLight", _SE(js_cc_scene_RenderScene_removeSpotLight)); + cls->defineFunction("removeSpotLights", _SE(js_cc_scene_RenderScene_removeSpotLights)); + cls->defineFunction("addPointLight", _SE(js_cc_scene_RenderScene_addPointLight)); + cls->defineFunction("removePointLight", _SE(js_cc_scene_RenderScene_removePointLight)); + cls->defineFunction("removePointLights", _SE(js_cc_scene_RenderScene_removePointLights)); + cls->defineFunction("addRangedDirLight", _SE(js_cc_scene_RenderScene_addRangedDirLight)); + cls->defineFunction("removeRangedDirLight", _SE(js_cc_scene_RenderScene_removeRangedDirLight)); + cls->defineFunction("removeRangedDirLights", _SE(js_cc_scene_RenderScene_removeRangedDirLights)); + cls->defineFunction("addModel", _SE(js_cc_scene_RenderScene_addModel)); + cls->defineFunction("removeModel", _SE(js_cc_scene_RenderScene_removeModel)); + cls->defineFunction("removeModels", _SE(js_cc_scene_RenderScene_removeModels)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_scene_RenderScene_onGlobalPipelineStateChanged)); + cls->defineFunction("getMainLight", _SE(js_cc_scene_RenderScene_getMainLight)); + cls->defineFunction("setMainLight", _SE(js_cc_scene_RenderScene_setMainLight)); + cls->defineFunction("generateModelId", _SE(js_cc_scene_RenderScene_generateModelId)); + cls->defineFunction("getOctree", _SE(js_cc_scene_RenderScene_getOctree)); + cls->defineFunction("updateOctree", _SE(js_cc_scene_RenderScene_updateOctree)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_RenderScene)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_RenderScene_proto = cls->getProto(); + __jsb_cc_scene_RenderScene_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IRenderWindowInfo_class = nullptr; +se::Object* __jsb_cc_scene_IRenderWindowInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IRenderWindowInfo) + +static bool js_cc_scene_IRenderWindowInfo_title_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->title, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_title_set) + +static bool js_cc_scene_IRenderWindowInfo_title_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->title, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->title, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_title_get) + +static bool js_cc_scene_IRenderWindowInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_width_set) + +static bool js_cc_scene_IRenderWindowInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_width_get) + +static bool js_cc_scene_IRenderWindowInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_height_set) + +static bool js_cc_scene_IRenderWindowInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_height_get) + +static bool js_cc_scene_IRenderWindowInfo_renderPassInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPassInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_renderPassInfo_set) + +static bool js_cc_scene_IRenderWindowInfo_renderPassInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPassInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderPassInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_renderPassInfo_get) + +static bool js_cc_scene_IRenderWindowInfo_swapchain_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->swapchain, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_swapchain_set) + +static bool js_cc_scene_IRenderWindowInfo_swapchain_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->swapchain, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->swapchain, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_swapchain_get) + +static bool js_cc_scene_IRenderWindowInfo_externalResLow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResLow, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_externalResLow_set) + +static bool js_cc_scene_IRenderWindowInfo_externalResLow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResLow, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResLow, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_externalResLow_get) + +static bool js_cc_scene_IRenderWindowInfo_externalResHigh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResHigh, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_externalResHigh_set) + +static bool js_cc_scene_IRenderWindowInfo_externalResHigh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResHigh, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResHigh, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_externalResHigh_get) + +static bool js_cc_scene_IRenderWindowInfo_externalFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalFlag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_externalFlag_set) + +static bool js_cc_scene_IRenderWindowInfo_externalFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalFlag, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalFlag, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_externalFlag_get) + +static bool js_new_cc_scene_IRenderWindowInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IRenderWindowInfo *result; + result = (cc::scene::IRenderWindowInfo *)new cc::scene::IRenderWindowInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IRenderWindowInfo, __jsb_cc_scene_IRenderWindowInfo_class, js_delete_cc_scene_IRenderWindowInfo) + +static bool js_delete_cc_scene_IRenderWindowInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IRenderWindowInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderWindowInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("title", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->title), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("renderPassInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPassInfo), ctx); + } + + + json->getProperty("swapchain", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->swapchain), ctx); + } + + + json->getProperty("externalResLow", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResLow), ctx); + } + + + json->getProperty("externalResHigh", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResHigh), ctx); + } + + + json->getProperty("externalFlag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalFlag), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IRenderWindowInfo(se::Object* obj) { + auto* cls = se::Class::create("IRenderWindowInfo", obj, nullptr, _SE(js_new_cc_scene_IRenderWindowInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("title", _SE(js_cc_scene_IRenderWindowInfo_title_get), _SE(js_cc_scene_IRenderWindowInfo_title_set)); + cls->defineProperty("width", _SE(js_cc_scene_IRenderWindowInfo_width_get), _SE(js_cc_scene_IRenderWindowInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_scene_IRenderWindowInfo_height_get), _SE(js_cc_scene_IRenderWindowInfo_height_set)); + cls->defineProperty("renderPassInfo", _SE(js_cc_scene_IRenderWindowInfo_renderPassInfo_get), _SE(js_cc_scene_IRenderWindowInfo_renderPassInfo_set)); + cls->defineProperty("swapchain", _SE(js_cc_scene_IRenderWindowInfo_swapchain_get), _SE(js_cc_scene_IRenderWindowInfo_swapchain_set)); + cls->defineProperty("externalResLow", _SE(js_cc_scene_IRenderWindowInfo_externalResLow_get), _SE(js_cc_scene_IRenderWindowInfo_externalResLow_set)); + cls->defineProperty("externalResHigh", _SE(js_cc_scene_IRenderWindowInfo_externalResHigh_get), _SE(js_cc_scene_IRenderWindowInfo_externalResHigh_set)); + cls->defineProperty("externalFlag", _SE(js_cc_scene_IRenderWindowInfo_externalFlag_get), _SE(js_cc_scene_IRenderWindowInfo_externalFlag_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IRenderWindowInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IRenderWindowInfo_proto = cls->getProto(); + __jsb_cc_scene_IRenderWindowInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_RenderWindow_class = nullptr; +se::Object* __jsb_cc_scene_RenderWindow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_RenderWindow) + +static bool js_new_cc_scene_RenderWindow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::RenderWindow *result; + result = (cc::scene::RenderWindow *)new cc::scene::RenderWindow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_RenderWindow, __jsb_cc_scene_RenderWindow_class, js_delete_cc_scene_RenderWindow) + +static bool js_delete_cc_scene_RenderWindow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_RenderWindow) + +static bool js_cc_scene_RenderWindow_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::scene::IRenderWindowInfo *arg3 = 0 ; + cc::scene::IRenderWindowInfo temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->initialize(arg2,*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_initialize) + +static bool js_cc_scene_RenderWindow_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_destroy) + +static bool js_cc_scene_RenderWindow_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_resize) + +static bool js_cc_scene_RenderWindow_extractRenderCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) 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(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)->extractRenderCameras(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_extractRenderCameras) + +static bool js_cc_scene_RenderWindow_attachCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_attachCamera) + +static bool js_cc_scene_RenderWindow_detachCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->detachCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_detachCamera) + +static bool js_cc_scene_RenderWindow_clearCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearCameras(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_clearCameras) + +static bool js_cc_scene_RenderWindow_sortCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->sortCameras(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_sortCameras) + +static bool js_cc_scene_RenderWindow_isRenderWindowResized(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::RenderWindow const *)arg1)->isRenderWindowResized(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_isRenderWindowResized) + +static bool js_cc_scene_RenderWindow_setRenderWindowResizeHandled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setRenderWindowResizeHandled(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_setRenderWindowResizeHandled) + +static bool js_cc_scene_RenderWindow_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_RenderWindow_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RenderWindow_width_get) + +static bool js_cc_scene_RenderWindow_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_RenderWindow_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RenderWindow_height_get) + +static bool js_cc_scene_RenderWindow_framebuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::gfx::Framebuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Framebuffer *)cc_scene_RenderWindow_framebuffer_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_scene_RenderWindow_framebuffer_get) + +static bool js_cc_scene_RenderWindow_cameras_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *) &cc_scene_RenderWindow_cameras_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_scene_RenderWindow_cameras_get) + +static bool js_cc_scene_RenderWindow_swapchain_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::gfx::Swapchain *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Swapchain *)cc_scene_RenderWindow_swapchain_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_scene_RenderWindow_swapchain_get) + +static bool js_cc_scene_RenderWindow_renderWindowId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_RenderWindow_renderWindowId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RenderWindow_renderWindowId_get) + +static bool js_cc_scene_RenderWindow_colorName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_RenderWindow_colorName_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_scene_RenderWindow_colorName_get) + +static bool js_cc_scene_RenderWindow_depthStencilName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_RenderWindow_depthStencilName_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_scene_RenderWindow_depthStencilName_get) + +bool js_register_cc_scene_RenderWindow(se::Object* obj) { + auto* cls = se::Class::create("RenderWindow", obj, nullptr, _SE(js_new_cc_scene_RenderWindow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_scene_RenderWindow_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_scene_RenderWindow_height_get), nullptr); + cls->defineProperty("framebuffer", _SE(js_cc_scene_RenderWindow_framebuffer_get), nullptr); + cls->defineProperty("cameras", _SE(js_cc_scene_RenderWindow_cameras_get), nullptr); + cls->defineProperty("swapchain", _SE(js_cc_scene_RenderWindow_swapchain_get), nullptr); + cls->defineProperty("renderWindowId", _SE(js_cc_scene_RenderWindow_renderWindowId_get), nullptr); + cls->defineProperty("colorName", _SE(js_cc_scene_RenderWindow_colorName_get), nullptr); + cls->defineProperty("depthStencilName", _SE(js_cc_scene_RenderWindow_depthStencilName_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_RenderWindow_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_RenderWindow_destroy)); + cls->defineFunction("resize", _SE(js_cc_scene_RenderWindow_resize)); + cls->defineFunction("extractRenderCameras", _SE(js_cc_scene_RenderWindow_extractRenderCameras)); + cls->defineFunction("attachCamera", _SE(js_cc_scene_RenderWindow_attachCamera)); + cls->defineFunction("detachCamera", _SE(js_cc_scene_RenderWindow_detachCamera)); + cls->defineFunction("clearCameras", _SE(js_cc_scene_RenderWindow_clearCameras)); + cls->defineFunction("sortCameras", _SE(js_cc_scene_RenderWindow_sortCameras)); + cls->defineFunction("isRenderWindowResized", _SE(js_cc_scene_RenderWindow_isRenderWindowResized)); + cls->defineFunction("setRenderWindowResizeHandled", _SE(js_cc_scene_RenderWindow_setRenderWindowResizeHandled)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_RenderWindow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_RenderWindow_proto = cls->getProto(); + __jsb_cc_scene_RenderWindow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_ICameraInfo_class = nullptr; +se::Object* __jsb_cc_scene_ICameraInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_ICameraInfo) + +static bool js_cc_scene_ICameraInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_name_set) + +static bool js_cc_scene_ICameraInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_name_get) + +static bool js_cc_scene_ICameraInfo_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->node, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_node_set) + +static bool js_cc_scene_ICameraInfo_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->node, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->node, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_node_get) + +static bool js_cc_scene_ICameraInfo_projection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->projection, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_projection_set) + +static bool js_cc_scene_ICameraInfo_projection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->projection, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->projection, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_projection_get) + +static bool js_cc_scene_ICameraInfo_targetDisplay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targetDisplay, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_targetDisplay_set) + +static bool js_cc_scene_ICameraInfo_targetDisplay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targetDisplay, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targetDisplay, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_targetDisplay_get) + +static bool js_cc_scene_ICameraInfo_window_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->window, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_window_set) + +static bool js_cc_scene_ICameraInfo_window_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->window, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->window, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_window_get) + +static bool js_cc_scene_ICameraInfo_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_priority_set) + +static bool js_cc_scene_ICameraInfo_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_priority_get) + +static bool js_cc_scene_ICameraInfo_pipeline_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pipeline, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_pipeline_set) + +static bool js_cc_scene_ICameraInfo_pipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pipeline, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pipeline, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_pipeline_get) + +static bool js_cc_scene_ICameraInfo_cameraType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cameraType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_cameraType_set) + +static bool js_cc_scene_ICameraInfo_cameraType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cameraType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cameraType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_cameraType_get) + +static bool js_cc_scene_ICameraInfo_trackingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->trackingType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_trackingType_set) + +static bool js_cc_scene_ICameraInfo_trackingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->trackingType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->trackingType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_trackingType_get) + +static bool js_cc_scene_ICameraInfo_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_usage_set) + +static bool js_cc_scene_ICameraInfo_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_usage_get) + +static bool js_new_cc_scene_ICameraInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::ICameraInfo *result; + result = (cc::scene::ICameraInfo *)new cc::scene::ICameraInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_ICameraInfo, __jsb_cc_scene_ICameraInfo_class, js_delete_cc_scene_ICameraInfo) + +static bool js_delete_cc_scene_ICameraInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_ICameraInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::ICameraInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("node", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->node), ctx); + } + + + json->getProperty("projection", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->projection), ctx); + } + + + json->getProperty("targetDisplay", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targetDisplay), ctx); + } + + + json->getProperty("window", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->window), ctx); + } + + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("pipeline", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pipeline), ctx); + } + + + json->getProperty("cameraType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cameraType), ctx); + } + + + json->getProperty("trackingType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->trackingType), ctx); + } + + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_ICameraInfo(se::Object* obj) { + auto* cls = se::Class::create("ICameraInfo", obj, nullptr, _SE(js_new_cc_scene_ICameraInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_ICameraInfo_name_get), _SE(js_cc_scene_ICameraInfo_name_set)); + cls->defineProperty("node", _SE(js_cc_scene_ICameraInfo_node_get), _SE(js_cc_scene_ICameraInfo_node_set)); + cls->defineProperty("projection", _SE(js_cc_scene_ICameraInfo_projection_get), _SE(js_cc_scene_ICameraInfo_projection_set)); + cls->defineProperty("targetDisplay", _SE(js_cc_scene_ICameraInfo_targetDisplay_get), _SE(js_cc_scene_ICameraInfo_targetDisplay_set)); + cls->defineProperty("window", _SE(js_cc_scene_ICameraInfo_window_get), _SE(js_cc_scene_ICameraInfo_window_set)); + cls->defineProperty("priority", _SE(js_cc_scene_ICameraInfo_priority_get), _SE(js_cc_scene_ICameraInfo_priority_set)); + cls->defineProperty("pipeline", _SE(js_cc_scene_ICameraInfo_pipeline_get), _SE(js_cc_scene_ICameraInfo_pipeline_set)); + cls->defineProperty("cameraType", _SE(js_cc_scene_ICameraInfo_cameraType_get), _SE(js_cc_scene_ICameraInfo_cameraType_set)); + cls->defineProperty("trackingType", _SE(js_cc_scene_ICameraInfo_trackingType_get), _SE(js_cc_scene_ICameraInfo_trackingType_set)); + cls->defineProperty("usage", _SE(js_cc_scene_ICameraInfo_usage_get), _SE(js_cc_scene_ICameraInfo_usage_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_ICameraInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_ICameraInfo_proto = cls->getProto(); + __jsb_cc_scene_ICameraInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Camera_class = nullptr; +se::Object* __jsb_cc_scene_Camera_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Camera) + +static bool js_new_cc_scene_Camera(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::scene::Camera *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::Camera *)new cc::scene::Camera(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Camera, __jsb_cc_scene_Camera_class, js_delete_cc_scene_Camera) + +static bool js_delete_cc_scene_Camera(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Camera) + +static bool js_cc_scene_Camera_getStandardExposureValue_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::scene::Camera::getStandardExposureValue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_getStandardExposureValue_static) + +static bool js_cc_scene_Camera_getStandardLightMeterScale_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::scene::Camera::getStandardLightMeterScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_getStandardLightMeterScale_static) + +static bool js_cc_scene_Camera_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::ICameraInfo *arg2 = 0 ; + cc::scene::ICameraInfo 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(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)(arg1)->initialize((cc::scene::ICameraInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_initialize) + +static bool js_cc_scene_Camera_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_destroy) + +static bool js_cc_scene_Camera_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_attachToScene) + +static bool js_cc_scene_Camera_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_detachFromScene) + +static bool js_cc_scene_Camera_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_resize) + +static bool js_cc_scene_Camera_setFixedSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFixedSize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_setFixedSize) + +static bool js_cc_scene_Camera_syncCameraEditor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->syncCameraEditor((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_syncCameraEditor) + +static bool js_cc_scene_Camera_update__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} + +static bool js_cc_scene_Camera_update__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} + +static bool js_cc_scene_Camera_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_Camera_update__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_scene_Camera_update__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Camera_update) + +static bool js_cc_scene_Camera_changeTargetWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->changeTargetWindow(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_changeTargetWindow) + +static bool js_cc_scene_Camera_setViewportInOrientedSpace(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + Rect *arg2 = 0 ; + 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(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)->setViewportInOrientedSpace((Rect const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_setViewportInOrientedSpace) + +static bool js_cc_scene_Camera_initGeometryRenderer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initGeometryRenderer(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_initGeometryRenderer) + +static bool js_cc_scene_Camera_detachCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachCamera(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_detachCamera) + +static bool js_cc_scene_Camera_isCullingEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Camera const *)arg1)->isCullingEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_isCullingEnabled) + +static bool js_cc_scene_Camera_setCullingEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCullingEnable(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_setCullingEnable) + +static bool js_cc_scene_Camera_calculateObliqueMat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->calculateObliqueMat((cc::Vec4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_calculateObliqueMat) + +static bool js_cc_scene_Camera_getClipSpaceMinz(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::Camera const *)arg1)->getClipSpaceMinz(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_getClipSpaceMinz) + +static bool js_cc_scene_Camera_iso_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraISO arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_iso_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_iso_set) + +static bool js_cc_scene_Camera_iso_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraISO result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraISO)cc_scene_Camera_iso_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_scene_Camera_iso_get) + +static bool js_cc_scene_Camera_isoValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_isoValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_isoValue_get) + +static bool js_cc_scene_Camera_ec_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_ec_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_ec_set) + +static bool js_cc_scene_Camera_ec_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_ec_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_ec_get) + +static bool js_cc_scene_Camera_exposure_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_exposure_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_exposure_get) + +static bool js_cc_scene_Camera_shutter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraShutter arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_shutter_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_shutter_set) + +static bool js_cc_scene_Camera_shutter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraShutter result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraShutter)cc_scene_Camera_shutter_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_scene_Camera_shutter_get) + +static bool js_cc_scene_Camera_shutterValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_shutterValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_shutterValue_get) + +static bool js_cc_scene_Camera_apertureValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_apertureValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_apertureValue_get) + +static bool js_cc_scene_Camera_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_width_get) + +static bool js_cc_scene_Camera_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_height_get) + +static bool js_cc_scene_Camera_aspect_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_aspect_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_aspect_get) + +static bool js_cc_scene_Camera_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_Camera_scene_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_scene_Camera_scene_get) + +static bool js_cc_scene_Camera_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_Camera_name_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_scene_Camera_name_get) + +static bool js_cc_scene_Camera_window_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_window_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_window_set) + +static bool js_cc_scene_Camera_window_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_scene_Camera_window_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_scene_Camera_window_get) + +static bool js_cc_scene_Camera_forward_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_forward_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_forward_set) + +static bool js_cc_scene_Camera_forward_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Camera_forward_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_scene_Camera_forward_get) + +static bool js_cc_scene_Camera_aperture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraAperture arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_aperture_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_aperture_set) + +static bool js_cc_scene_Camera_aperture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraAperture result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraAperture)cc_scene_Camera_aperture_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_scene_Camera_aperture_get) + +static bool js_cc_scene_Camera_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_position_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_position_set) + +static bool js_cc_scene_Camera_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Camera_position_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_scene_Camera_position_get) + +static bool js_cc_scene_Camera_projectionType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraProjection arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_projectionType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_projectionType_set) + +static bool js_cc_scene_Camera_projectionType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraProjection result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraProjection)cc_scene_Camera_projectionType_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_scene_Camera_projectionType_get) + +static bool js_cc_scene_Camera_fovAxis_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraFOVAxis arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_fovAxis_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_fovAxis_set) + +static bool js_cc_scene_Camera_fovAxis_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraFOVAxis result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraFOVAxis)cc_scene_Camera_fovAxis_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_scene_Camera_fovAxis_get) + +static bool js_cc_scene_Camera_fov_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_fov_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_fov_set) + +static bool js_cc_scene_Camera_fov_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_fov_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_fov_get) + +static bool js_cc_scene_Camera_nearClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_nearClip_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_nearClip_set) + +static bool js_cc_scene_Camera_nearClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_nearClip_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_nearClip_get) + +static bool js_cc_scene_Camera_farClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_farClip_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_farClip_set) + +static bool js_cc_scene_Camera_farClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_farClip_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_farClip_get) + +static bool js_cc_scene_Camera_viewport_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Rect *arg2 = 0 ; + cc::Rect temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_viewport_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_viewport_set) + +static bool js_cc_scene_Camera_viewport_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Rect *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Rect *) &cc_scene_Camera_viewport_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_scene_Camera_viewport_get) + +static bool js_cc_scene_Camera_orthoHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_orthoHeight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_orthoHeight_set) + +static bool js_cc_scene_Camera_orthoHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_orthoHeight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_orthoHeight_get) + +static bool js_cc_scene_Camera_clearColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_clearColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearColor_set) + +static bool js_cc_scene_Camera_clearColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Color *) &cc_scene_Camera_clearColor_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_scene_Camera_clearColor_get) + +static bool js_cc_scene_Camera_clearDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_clearDepth_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearDepth_set) + +static bool js_cc_scene_Camera_clearDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_clearDepth_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_clearDepth_get) + +static bool js_cc_scene_Camera_clearFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::ClearFlagBit arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_clearFlag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearFlag_set) + +static bool js_cc_scene_Camera_clearFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::ClearFlagBit result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_clearFlag_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_scene_Camera_clearFlag_get) + +static bool js_cc_scene_Camera_clearStencil_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_clearStencil_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearStencil_set) + +static bool js_cc_scene_Camera_clearStencil_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_clearStencil_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_clearStencil_get) + +static bool js_cc_scene_Camera_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_enabled_set) + +static bool js_cc_scene_Camera_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Camera_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_enabled_get) + +static bool js_cc_scene_Camera_frustum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_frustum_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_frustum_set) + +static bool js_cc_scene_Camera_frustum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::geometry::Frustum *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Frustum *) &cc_scene_Camera_frustum_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_scene_Camera_frustum_get) + +static bool js_cc_scene_Camera_isWindowSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_isWindowSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_isWindowSize_set) + +static bool js_cc_scene_Camera_isWindowSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Camera_isWindowSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_isWindowSize_get) + +static bool js_cc_scene_Camera_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_priority_set) + +static bool js_cc_scene_Camera_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_priority_get) + +static bool js_cc_scene_Camera_screenScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_screenScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_screenScale_set) + +static bool js_cc_scene_Camera_screenScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_screenScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_screenScale_get) + +static bool js_cc_scene_Camera_visibility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_visibility_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_visibility_set) + +static bool js_cc_scene_Camera_visibility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_visibility_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_visibility_get) + +static bool js_cc_scene_Camera_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_node_set) + +static bool js_cc_scene_Camera_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Camera_node_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_scene_Camera_node_get) + +static bool js_cc_scene_Camera_surfaceTransform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::SurfaceTransform result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_surfaceTransform_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_scene_Camera_surfaceTransform_get) + +static bool js_cc_scene_Camera_geometryRenderer_get(se::State& s) +{ +#if CC_USE_GEOMETRY_RENDERER + + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::pipeline::GeometryRenderer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::GeometryRenderer *)cc_scene_Camera_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_scene_Camera_geometryRenderer_get) + +static bool js_cc_scene_Camera_systemWindowId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_systemWindowId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_systemWindowId_get) + +static bool js_cc_scene_Camera_cameraUsage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraUsage arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_cameraUsage_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_cameraUsage_set) + +static bool js_cc_scene_Camera_cameraUsage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraUsage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraUsage)cc_scene_Camera_cameraUsage_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_scene_Camera_cameraUsage_get) + +static bool js_cc_scene_Camera_trackingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::TrackingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_trackingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_trackingType_set) + +static bool js_cc_scene_Camera_trackingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::TrackingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::TrackingType)cc_scene_Camera_trackingType_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_scene_Camera_trackingType_get) + +static bool js_cc_scene_Camera_cameraType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_cameraType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_cameraType_set) + +static bool js_cc_scene_Camera_cameraType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraType)cc_scene_Camera_cameraType_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_scene_Camera_cameraType_get) + +static bool js_cc_scene_Camera_cameraId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_cameraId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_cameraId_get) + +bool js_register_cc_scene_Camera(se::Object* obj) { + auto* cls = se::Class::create("Camera", obj, nullptr, _SE(js_new_cc_scene_Camera)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("iso", _SE(js_cc_scene_Camera_iso_get), _SE(js_cc_scene_Camera_iso_set)); + cls->defineProperty("isoValue", _SE(js_cc_scene_Camera_isoValue_get), nullptr); + cls->defineProperty("ec", _SE(js_cc_scene_Camera_ec_get), _SE(js_cc_scene_Camera_ec_set)); + cls->defineProperty("exposure", _SE(js_cc_scene_Camera_exposure_get), nullptr); + cls->defineProperty("shutter", _SE(js_cc_scene_Camera_shutter_get), _SE(js_cc_scene_Camera_shutter_set)); + cls->defineProperty("shutterValue", _SE(js_cc_scene_Camera_shutterValue_get), nullptr); + cls->defineProperty("apertureValue", _SE(js_cc_scene_Camera_apertureValue_get), nullptr); + cls->defineProperty("width", _SE(js_cc_scene_Camera_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_scene_Camera_height_get), nullptr); + cls->defineProperty("aspect", _SE(js_cc_scene_Camera_aspect_get), nullptr); + cls->defineProperty("scene", _SE(js_cc_scene_Camera_scene_get), nullptr); + cls->defineProperty("name", _SE(js_cc_scene_Camera_name_get), nullptr); + cls->defineProperty("window", _SE(js_cc_scene_Camera_window_get), _SE(js_cc_scene_Camera_window_set)); + cls->defineProperty("forward", _SE(js_cc_scene_Camera_forward_get), _SE(js_cc_scene_Camera_forward_set)); + cls->defineProperty("aperture", _SE(js_cc_scene_Camera_aperture_get), _SE(js_cc_scene_Camera_aperture_set)); + cls->defineProperty("position", _SE(js_cc_scene_Camera_position_get), _SE(js_cc_scene_Camera_position_set)); + cls->defineProperty("projectionType", _SE(js_cc_scene_Camera_projectionType_get), _SE(js_cc_scene_Camera_projectionType_set)); + cls->defineProperty("fovAxis", _SE(js_cc_scene_Camera_fovAxis_get), _SE(js_cc_scene_Camera_fovAxis_set)); + cls->defineProperty("fov", _SE(js_cc_scene_Camera_fov_get), _SE(js_cc_scene_Camera_fov_set)); + cls->defineProperty("nearClip", _SE(js_cc_scene_Camera_nearClip_get), _SE(js_cc_scene_Camera_nearClip_set)); + cls->defineProperty("farClip", _SE(js_cc_scene_Camera_farClip_get), _SE(js_cc_scene_Camera_farClip_set)); + cls->defineProperty("viewport", _SE(js_cc_scene_Camera_viewport_get), _SE(js_cc_scene_Camera_viewport_set)); + cls->defineProperty("orthoHeight", _SE(js_cc_scene_Camera_orthoHeight_get), _SE(js_cc_scene_Camera_orthoHeight_set)); + cls->defineProperty("clearColor", _SE(js_cc_scene_Camera_clearColor_get), _SE(js_cc_scene_Camera_clearColor_set)); + cls->defineProperty("clearDepth", _SE(js_cc_scene_Camera_clearDepth_get), _SE(js_cc_scene_Camera_clearDepth_set)); + cls->defineProperty("clearFlag", _SE(js_cc_scene_Camera_clearFlag_get), _SE(js_cc_scene_Camera_clearFlag_set)); + cls->defineProperty("clearStencil", _SE(js_cc_scene_Camera_clearStencil_get), _SE(js_cc_scene_Camera_clearStencil_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_Camera_enabled_get), _SE(js_cc_scene_Camera_enabled_set)); + cls->defineProperty("frustum", _SE(js_cc_scene_Camera_frustum_get), _SE(js_cc_scene_Camera_frustum_set)); + cls->defineProperty("isWindowSize", _SE(js_cc_scene_Camera_isWindowSize_get), _SE(js_cc_scene_Camera_isWindowSize_set)); + cls->defineProperty("priority", _SE(js_cc_scene_Camera_priority_get), _SE(js_cc_scene_Camera_priority_set)); + cls->defineProperty("screenScale", _SE(js_cc_scene_Camera_screenScale_get), _SE(js_cc_scene_Camera_screenScale_set)); + cls->defineProperty("visibility", _SE(js_cc_scene_Camera_visibility_get), _SE(js_cc_scene_Camera_visibility_set)); + cls->defineProperty("node", _SE(js_cc_scene_Camera_node_get), _SE(js_cc_scene_Camera_node_set)); + cls->defineProperty("surfaceTransform", _SE(js_cc_scene_Camera_surfaceTransform_get), nullptr); + cls->defineProperty("geometryRenderer", _SE(js_cc_scene_Camera_geometryRenderer_get), nullptr); + cls->defineProperty("systemWindowId", _SE(js_cc_scene_Camera_systemWindowId_get), nullptr); + cls->defineProperty("cameraUsage", _SE(js_cc_scene_Camera_cameraUsage_get), _SE(js_cc_scene_Camera_cameraUsage_set)); + cls->defineProperty("trackingType", _SE(js_cc_scene_Camera_trackingType_get), _SE(js_cc_scene_Camera_trackingType_set)); + cls->defineProperty("cameraType", _SE(js_cc_scene_Camera_cameraType_get), _SE(js_cc_scene_Camera_cameraType_set)); + cls->defineProperty("cameraId", _SE(js_cc_scene_Camera_cameraId_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Camera_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_Camera_destroy)); + cls->defineFunction("attachToScene", _SE(js_cc_scene_Camera_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_Camera_detachFromScene)); + cls->defineFunction("resize", _SE(js_cc_scene_Camera_resize)); + cls->defineFunction("setFixedSize", _SE(js_cc_scene_Camera_setFixedSize)); + cls->defineFunction("syncCameraEditor", _SE(js_cc_scene_Camera_syncCameraEditor)); + cls->defineFunction("update", _SE(js_cc_scene_Camera_update)); + cls->defineFunction("changeTargetWindow", _SE(js_cc_scene_Camera_changeTargetWindow)); + cls->defineFunction("setViewportInOrientedSpace", _SE(js_cc_scene_Camera_setViewportInOrientedSpace)); + cls->defineFunction("initGeometryRenderer", _SE(js_cc_scene_Camera_initGeometryRenderer)); + cls->defineFunction("detachCamera", _SE(js_cc_scene_Camera_detachCamera)); + cls->defineFunction("isCullingEnabled", _SE(js_cc_scene_Camera_isCullingEnabled)); + cls->defineFunction("setCullingEnable", _SE(js_cc_scene_Camera_setCullingEnable)); + cls->defineFunction("calculateObliqueMat", _SE(js_cc_scene_Camera_calculateObliqueMat)); + cls->defineFunction("getClipSpaceMinz", _SE(js_cc_scene_Camera_getClipSpaceMinz)); + + + cls->defineStaticFunction("getStandardExposureValue", _SE(js_cc_scene_Camera_getStandardExposureValue_static)); + cls->defineStaticFunction("getStandardLightMeterScale", _SE(js_cc_scene_Camera_getStandardLightMeterScale_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Camera)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Camera_proto = cls->getProto(); + __jsb_cc_scene_Camera_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Ambient_class = nullptr; +se::Object* __jsb_cc_scene_Ambient_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Ambient) + +static bool js_new_cc_scene_Ambient(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Ambient *result; + result = (cc::scene::Ambient *)new cc::scene::Ambient(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Ambient, __jsb_cc_scene_Ambient_class, js_delete_cc_scene_Ambient) + +static bool js_delete_cc_scene_Ambient(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Ambient) + +static bool js_cc_scene_Ambient_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::scene::AmbientInfo *arg2 = (cc::scene::AmbientInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Ambient_initialize) + +static bool js_cc_scene_Ambient_skyColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Ambient_skyColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_skyColor_set) + +static bool js_cc_scene_Ambient_skyColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_Ambient_skyColor_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_scene_Ambient_skyColor_get) + +static bool js_cc_scene_Ambient_skyIllum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Ambient_skyIllum_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_skyIllum_set) + +static bool js_cc_scene_Ambient_skyIllum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Ambient_skyIllum_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Ambient_skyIllum_get) + +static bool js_cc_scene_Ambient_groundAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Ambient_groundAlbedo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_groundAlbedo_set) + +static bool js_cc_scene_Ambient_groundAlbedo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_Ambient_groundAlbedo_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_scene_Ambient_groundAlbedo_get) + +static bool js_cc_scene_Ambient_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Ambient_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_enabled_set) + +static bool js_cc_scene_Ambient_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Ambient_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Ambient_enabled_get) + +static bool js_cc_scene_Ambient_mipmapCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + uint8_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Ambient_mipmapCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_mipmapCount_set) + +static bool js_cc_scene_Ambient_mipmapCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + uint8_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Ambient_mipmapCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Ambient_mipmapCount_get) + +bool js_register_cc_scene_Ambient(se::Object* obj) { + auto* cls = se::Class::create("Ambient", obj, nullptr, _SE(js_new_cc_scene_Ambient)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("skyColor", _SE(js_cc_scene_Ambient_skyColor_get), _SE(js_cc_scene_Ambient_skyColor_set)); + cls->defineProperty("skyIllum", _SE(js_cc_scene_Ambient_skyIllum_get), _SE(js_cc_scene_Ambient_skyIllum_set)); + cls->defineProperty("groundAlbedo", _SE(js_cc_scene_Ambient_groundAlbedo_get), _SE(js_cc_scene_Ambient_groundAlbedo_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_Ambient_enabled_get), _SE(js_cc_scene_Ambient_enabled_set)); + cls->defineProperty("mipmapCount", _SE(js_cc_scene_Ambient_mipmapCount_get), _SE(js_cc_scene_Ambient_mipmapCount_set)); + + cls->defineFunction("initialize", _SE(js_cc_scene_Ambient_initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Ambient)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Ambient_proto = cls->getProto(); + __jsb_cc_scene_Ambient_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_AmbientInfo_class = nullptr; +se::Object* __jsb_cc_scene_AmbientInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_AmbientInfo) + +static bool js_new_cc_scene_AmbientInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::AmbientInfo *result; + result = (cc::scene::AmbientInfo *)new cc::scene::AmbientInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_AmbientInfo, __jsb_cc_scene_AmbientInfo_class, js_delete_cc_scene_AmbientInfo) + +static bool js_delete_cc_scene_AmbientInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_AmbientInfo) + +static bool js_cc_scene_AmbientInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::scene::Ambient *arg2 = (cc::scene::Ambient *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_AmbientInfo_activate) + +static bool js_cc_scene_AmbientInfo__skyColorHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyColorHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyColorHDR_set) + +static bool js_cc_scene_AmbientInfo__skyColorHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyColorHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_skyColorHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyColorHDR_get) + +static bool js_cc_scene_AmbientInfo__skyIllumHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyIllumHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyIllumHDR_set) + +static bool js_cc_scene_AmbientInfo__skyIllumHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyIllumHDR, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyIllumHDR_get) + +static bool js_cc_scene_AmbientInfo__groundAlbedoHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_groundAlbedoHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__groundAlbedoHDR_set) + +static bool js_cc_scene_AmbientInfo__groundAlbedoHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_groundAlbedoHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_groundAlbedoHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__groundAlbedoHDR_get) + +static bool js_cc_scene_AmbientInfo__skyColorLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyColorLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyColorLDR_set) + +static bool js_cc_scene_AmbientInfo__skyColorLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyColorLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_skyColorLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyColorLDR_get) + +static bool js_cc_scene_AmbientInfo__skyIllumLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyIllumLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyIllumLDR_set) + +static bool js_cc_scene_AmbientInfo__skyIllumLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyIllumLDR, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyIllumLDR_get) + +static bool js_cc_scene_AmbientInfo__groundAlbedoLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_groundAlbedoLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__groundAlbedoLDR_set) + +static bool js_cc_scene_AmbientInfo__groundAlbedoLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_groundAlbedoLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_groundAlbedoLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__groundAlbedoLDR_get) + +static bool js_cc_scene_AmbientInfo_skyColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_skyColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_skyColor_set) + +static bool js_cc_scene_AmbientInfo_skyIllum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_AmbientInfo_skyIllum_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_skyIllum_set) + +static bool js_cc_scene_AmbientInfo_skyIllum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_AmbientInfo_skyIllum_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo_skyIllum_get) + +static bool js_cc_scene_AmbientInfo_groundAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_groundAlbedo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_groundAlbedo_set) + +static bool js_cc_scene_AmbientInfo__skyColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo__skyColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyColor_set) + +static bool js_cc_scene_AmbientInfo__skyColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo__skyColor_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_scene_AmbientInfo__skyColor_get) + +static bool js_cc_scene_AmbientInfo__skyIllum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_AmbientInfo__skyIllum_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyIllum_set) + +static bool js_cc_scene_AmbientInfo__skyIllum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_AmbientInfo__skyIllum_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyIllum_get) + +static bool js_cc_scene_AmbientInfo__groundAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo__groundAlbedo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__groundAlbedo_set) + +static bool js_cc_scene_AmbientInfo__groundAlbedo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo__groundAlbedo_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_scene_AmbientInfo__groundAlbedo_get) + +static bool js_cc_scene_AmbientInfo_skyColorLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo_skyColorLDR_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_scene_AmbientInfo_skyColorLDR_get) + +static bool js_cc_scene_AmbientInfo_groundAlbedoLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo_groundAlbedoLDR_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_scene_AmbientInfo_groundAlbedoLDR_get) + +static bool js_cc_scene_AmbientInfo_skyIllumLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_AmbientInfo_skyIllumLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo_skyIllumLDR_get) + +static bool js_cc_scene_AmbientInfo_skyLightingColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_skyLightingColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_skyLightingColor_set) + +static bool js_cc_scene_AmbientInfo_skyLightingColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_AmbientInfo_skyLightingColor_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_scene_AmbientInfo_skyLightingColor_get) + +static bool js_cc_scene_AmbientInfo_groundLightingColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_groundLightingColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_groundLightingColor_set) + +static bool js_cc_scene_AmbientInfo_groundLightingColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_AmbientInfo_groundLightingColor_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_scene_AmbientInfo_groundLightingColor_get) + +bool js_register_cc_scene_AmbientInfo(se::Object* obj) { + auto* cls = se::Class::create("AmbientInfo", obj, nullptr, _SE(js_new_cc_scene_AmbientInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_skyColorHDR", _SE(js_cc_scene_AmbientInfo__skyColorHDR_get), _SE(js_cc_scene_AmbientInfo__skyColorHDR_set)); + cls->defineProperty("_skyIllumHDR", _SE(js_cc_scene_AmbientInfo__skyIllumHDR_get), _SE(js_cc_scene_AmbientInfo__skyIllumHDR_set)); + cls->defineProperty("_groundAlbedoHDR", _SE(js_cc_scene_AmbientInfo__groundAlbedoHDR_get), _SE(js_cc_scene_AmbientInfo__groundAlbedoHDR_set)); + cls->defineProperty("_skyColorLDR", _SE(js_cc_scene_AmbientInfo__skyColorLDR_get), _SE(js_cc_scene_AmbientInfo__skyColorLDR_set)); + cls->defineProperty("_skyIllumLDR", _SE(js_cc_scene_AmbientInfo__skyIllumLDR_get), _SE(js_cc_scene_AmbientInfo__skyIllumLDR_set)); + cls->defineProperty("_groundAlbedoLDR", _SE(js_cc_scene_AmbientInfo__groundAlbedoLDR_get), _SE(js_cc_scene_AmbientInfo__groundAlbedoLDR_set)); + cls->defineProperty("skyColor", nullptr, _SE(js_cc_scene_AmbientInfo_skyColor_set)); + cls->defineProperty("skyIllum", _SE(js_cc_scene_AmbientInfo_skyIllum_get), _SE(js_cc_scene_AmbientInfo_skyIllum_set)); + cls->defineProperty("groundAlbedo", nullptr, _SE(js_cc_scene_AmbientInfo_groundAlbedo_set)); + cls->defineProperty("_skyColor", _SE(js_cc_scene_AmbientInfo__skyColor_get), _SE(js_cc_scene_AmbientInfo__skyColor_set)); + cls->defineProperty("_skyIllum", _SE(js_cc_scene_AmbientInfo__skyIllum_get), _SE(js_cc_scene_AmbientInfo__skyIllum_set)); + cls->defineProperty("_groundAlbedo", _SE(js_cc_scene_AmbientInfo__groundAlbedo_get), _SE(js_cc_scene_AmbientInfo__groundAlbedo_set)); + cls->defineProperty("skyColorLDR", _SE(js_cc_scene_AmbientInfo_skyColorLDR_get), nullptr); + cls->defineProperty("groundAlbedoLDR", _SE(js_cc_scene_AmbientInfo_groundAlbedoLDR_get), nullptr); + cls->defineProperty("skyIllumLDR", _SE(js_cc_scene_AmbientInfo_skyIllumLDR_get), nullptr); + cls->defineProperty("skyLightingColor", _SE(js_cc_scene_AmbientInfo_skyLightingColor_get), _SE(js_cc_scene_AmbientInfo_skyLightingColor_set)); + cls->defineProperty("groundLightingColor", _SE(js_cc_scene_AmbientInfo_groundLightingColor_get), _SE(js_cc_scene_AmbientInfo_groundLightingColor_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_AmbientInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_AmbientInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_AmbientInfo_proto = cls->getProto(); + __jsb_cc_scene_AmbientInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_ReflectionProbe_class = nullptr; +se::Object* __jsb_cc_scene_ReflectionProbe_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_ReflectionProbe) + +static bool js_new_cc_scene_ReflectionProbe(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int32_t arg1 ; + cc::scene::ReflectionProbe *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::ReflectionProbe *)new cc::scene::ReflectionProbe(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_ReflectionProbe, __jsb_cc_scene_ReflectionProbe_class, js_delete_cc_scene_ReflectionProbe) + +static bool js_delete_cc_scene_ReflectionProbe(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_ReflectionProbe) + +static bool js_cc_scene_ReflectionProbe_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + cc::Node *arg3 = (cc::Node *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_initialize) + +static bool js_cc_scene_ReflectionProbe_getProbeId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + int32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::ReflectionProbe const *)arg1)->getProbeId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_getProbeId) + +static bool js_cc_scene_ReflectionProbe_needRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::ReflectionProbe const *)arg1)->needRender(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_needRender) + +static bool js_cc_scene_ReflectionProbe_setNeedRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setNeedRender(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_setNeedRender) + +static bool js_cc_scene_ReflectionProbe_setCameraNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCameraNode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_setCameraNode) + +static bool js_cc_scene_ReflectionProbe_getCameraNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *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(s); + if (nullptr == arg1) return true; + result = (cc::Node *)((cc::scene::ReflectionProbe const *)arg1)->getCameraNode(); + + 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_scene_ReflectionProbe_getCameraNode) + +static bool js_cc_scene_ReflectionProbe_updateBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateBoundingBox(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_updateBoundingBox) + +static bool js_cc_scene_ReflectionProbe_syncCameraParams(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->syncCameraParams((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_syncCameraParams) + +static bool js_cc_scene_ReflectionProbe_transformReflectionCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->transformReflectionCamera((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_transformReflectionCamera) + +static bool js_cc_scene_ReflectionProbe_renderPlanarReflection(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->renderPlanarReflection((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_renderPlanarReflection) + +static bool js_cc_scene_ReflectionProbe_switchProbeType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + int32_t arg2 ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->switchProbeType(arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_switchProbeType) + +static bool js_cc_scene_ReflectionProbe_reflect_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Vec3 *arg1 = 0 ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::Vec3 temp1 ; + cc::Vec3 temp2 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::scene::ReflectionProbe::reflect((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2,arg3); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_reflect_static) + +static bool js_cc_scene_ReflectionProbe_updatePlanarTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updatePlanarTexture((cc::scene::RenderScene const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_updatePlanarTexture) + +static bool js_cc_scene_ReflectionProbe_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_destroy) + +static bool js_cc_scene_ReflectionProbe_enable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->enable(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_enable) + +static bool js_cc_scene_ReflectionProbe_disable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->disable(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_disable) + +static bool js_cc_scene_ReflectionProbe_validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::ReflectionProbe const *)arg1)->validate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_validate) + +static bool js_cc_scene_ReflectionProbe_initBakedTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initBakedTextures(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_initBakedTextures) + +static bool js_cc_scene_ReflectionProbe_captureCubemap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->captureCubemap(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_captureCubemap) + +static bool js_cc_scene_ReflectionProbe_resetCameraParams(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetCameraParams(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_resetCameraParams) + +static bool js_cc_scene_ReflectionProbe_updateCameraDir(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + int32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateCameraDir(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_updateCameraDir) + +static bool js_cc_scene_ReflectionProbe_renderArea(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Vec2 result; + cc::Vec2 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::ReflectionProbe const *)arg1)->renderArea(); + + temp = ccnew cc::Vec2(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_renderArea) + +static bool js_cc_scene_ReflectionProbe_packBackgroundColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->packBackgroundColor(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_packBackgroundColor) + +static bool js_cc_scene_ReflectionProbe_isRGBE(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::ReflectionProbe const *)arg1)->isRGBE(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_isRGBE) + +static bool js_cc_scene_ReflectionProbe_probeType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::ReflectionProbe::ProbeType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_probeType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_probeType_set) + +static bool js_cc_scene_ReflectionProbe_probeType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::ReflectionProbe::ProbeType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ReflectionProbe::ProbeType)cc_scene_ReflectionProbe_probeType_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_scene_ReflectionProbe_probeType_get) + +static bool js_cc_scene_ReflectionProbe_resolution_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_resolution_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_resolution_set) + +static bool js_cc_scene_ReflectionProbe_resolution_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ReflectionProbe_resolution_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ReflectionProbe_resolution_get) + +static bool js_cc_scene_ReflectionProbe_clearFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::ClearFlagBit arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_clearFlag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_clearFlag_set) + +static bool js_cc_scene_ReflectionProbe_clearFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::ClearFlagBit result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ReflectionProbe_clearFlag_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_scene_ReflectionProbe_clearFlag_get) + +static bool js_cc_scene_ReflectionProbe_backgroundColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ReflectionProbe_backgroundColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_backgroundColor_set) + +static bool js_cc_scene_ReflectionProbe_backgroundColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Color *) &cc_scene_ReflectionProbe_backgroundColor_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_scene_ReflectionProbe_backgroundColor_get) + +static bool js_cc_scene_ReflectionProbe_visibility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_visibility_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_visibility_set) + +static bool js_cc_scene_ReflectionProbe_visibility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ReflectionProbe_visibility_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ReflectionProbe_visibility_get) + +static bool js_cc_scene_ReflectionProbe_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ReflectionProbe_size_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_size_set) + +static bool js_cc_scene_ReflectionProbe_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_ReflectionProbe_size_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_scene_ReflectionProbe_size_get) + +static bool js_cc_scene_ReflectionProbe_boundingBox_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_ReflectionProbe_boundingBox_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_scene_ReflectionProbe_boundingBox_get) + +static bool js_cc_scene_ReflectionProbe_previewSphere_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ReflectionProbe_previewSphere_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_previewSphere_set) + +static bool js_cc_scene_ReflectionProbe_previewSphere_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_ReflectionProbe_previewSphere_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_scene_ReflectionProbe_previewSphere_get) + +static bool js_cc_scene_ReflectionProbe_previewPlane_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ReflectionProbe_previewPlane_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_previewPlane_set) + +static bool js_cc_scene_ReflectionProbe_previewPlane_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_ReflectionProbe_previewPlane_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_scene_ReflectionProbe_previewPlane_get) + +static bool js_cc_scene_ReflectionProbe_bakedCubeTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::RenderTexture > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::RenderTexture > > *) &cc_scene_ReflectionProbe_bakedCubeTextures_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_scene_ReflectionProbe_bakedCubeTextures_get) + +static bool js_cc_scene_ReflectionProbe_cubemap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ReflectionProbe_cubemap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_cubemap_set) + +static bool js_cc_scene_ReflectionProbe_cubemap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_ReflectionProbe_cubemap_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_scene_ReflectionProbe_cubemap_get) + +static bool js_cc_scene_ReflectionProbe_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_ReflectionProbe_node_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_scene_ReflectionProbe_node_get) + +static bool js_cc_scene_ReflectionProbe_realtimePlanarTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::RenderTexture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::RenderTexture *)cc_scene_ReflectionProbe_realtimePlanarTexture_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_scene_ReflectionProbe_realtimePlanarTexture_get) + +static bool js_cc_scene_ReflectionProbe_camera_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Camera *)cc_scene_ReflectionProbe_camera_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_scene_ReflectionProbe_camera_get) + +bool js_register_cc_scene_ReflectionProbe(se::Object* obj) { + auto* cls = se::Class::create("ReflectionProbe", obj, nullptr, _SE(js_new_cc_scene_ReflectionProbe)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("probeType", _SE(js_cc_scene_ReflectionProbe_probeType_get), _SE(js_cc_scene_ReflectionProbe_probeType_set)); + cls->defineProperty("resolution", _SE(js_cc_scene_ReflectionProbe_resolution_get), _SE(js_cc_scene_ReflectionProbe_resolution_set)); + cls->defineProperty("clearFlag", _SE(js_cc_scene_ReflectionProbe_clearFlag_get), _SE(js_cc_scene_ReflectionProbe_clearFlag_set)); + cls->defineProperty("backgroundColor", _SE(js_cc_scene_ReflectionProbe_backgroundColor_get), _SE(js_cc_scene_ReflectionProbe_backgroundColor_set)); + cls->defineProperty("visibility", _SE(js_cc_scene_ReflectionProbe_visibility_get), _SE(js_cc_scene_ReflectionProbe_visibility_set)); + cls->defineProperty("size", _SE(js_cc_scene_ReflectionProbe_size_get), _SE(js_cc_scene_ReflectionProbe_size_set)); + cls->defineProperty("boundingBox", _SE(js_cc_scene_ReflectionProbe_boundingBox_get), nullptr); + cls->defineProperty("previewSphere", _SE(js_cc_scene_ReflectionProbe_previewSphere_get), _SE(js_cc_scene_ReflectionProbe_previewSphere_set)); + cls->defineProperty("previewPlane", _SE(js_cc_scene_ReflectionProbe_previewPlane_get), _SE(js_cc_scene_ReflectionProbe_previewPlane_set)); + cls->defineProperty("bakedCubeTextures", _SE(js_cc_scene_ReflectionProbe_bakedCubeTextures_get), nullptr); + cls->defineProperty("cubemap", _SE(js_cc_scene_ReflectionProbe_cubemap_get), _SE(js_cc_scene_ReflectionProbe_cubemap_set)); + cls->defineProperty("node", _SE(js_cc_scene_ReflectionProbe_node_get), nullptr); + cls->defineProperty("realtimePlanarTexture", _SE(js_cc_scene_ReflectionProbe_realtimePlanarTexture_get), nullptr); + cls->defineProperty("camera", _SE(js_cc_scene_ReflectionProbe_camera_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_ReflectionProbe_initialize)); + cls->defineFunction("getProbeId", _SE(js_cc_scene_ReflectionProbe_getProbeId)); + cls->defineFunction("needRender", _SE(js_cc_scene_ReflectionProbe_needRender)); + cls->defineFunction("setNeedRender", _SE(js_cc_scene_ReflectionProbe_setNeedRender)); + cls->defineFunction("setCameraNode", _SE(js_cc_scene_ReflectionProbe_setCameraNode)); + cls->defineFunction("getCameraNode", _SE(js_cc_scene_ReflectionProbe_getCameraNode)); + cls->defineFunction("updateBoundingBox", _SE(js_cc_scene_ReflectionProbe_updateBoundingBox)); + cls->defineFunction("syncCameraParams", _SE(js_cc_scene_ReflectionProbe_syncCameraParams)); + cls->defineFunction("transformReflectionCamera", _SE(js_cc_scene_ReflectionProbe_transformReflectionCamera)); + cls->defineFunction("renderPlanarReflection", _SE(js_cc_scene_ReflectionProbe_renderPlanarReflection)); + cls->defineFunction("switchProbeType", _SE(js_cc_scene_ReflectionProbe_switchProbeType)); + cls->defineFunction("updatePlanarTexture", _SE(js_cc_scene_ReflectionProbe_updatePlanarTexture)); + cls->defineFunction("destroy", _SE(js_cc_scene_ReflectionProbe_destroy)); + cls->defineFunction("enable", _SE(js_cc_scene_ReflectionProbe_enable)); + cls->defineFunction("disable", _SE(js_cc_scene_ReflectionProbe_disable)); + cls->defineFunction("validate", _SE(js_cc_scene_ReflectionProbe_validate)); + cls->defineFunction("initBakedTextures", _SE(js_cc_scene_ReflectionProbe_initBakedTextures)); + cls->defineFunction("captureCubemap", _SE(js_cc_scene_ReflectionProbe_captureCubemap)); + cls->defineFunction("resetCameraParams", _SE(js_cc_scene_ReflectionProbe_resetCameraParams)); + cls->defineFunction("updateCameraDir", _SE(js_cc_scene_ReflectionProbe_updateCameraDir)); + cls->defineFunction("renderArea", _SE(js_cc_scene_ReflectionProbe_renderArea)); + cls->defineFunction("packBackgroundColor", _SE(js_cc_scene_ReflectionProbe_packBackgroundColor)); + cls->defineFunction("isRGBE", _SE(js_cc_scene_ReflectionProbe_isRGBE)); + + + cls->defineStaticFunction("reflect", _SE(js_cc_scene_ReflectionProbe_reflect_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_ReflectionProbe)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_ReflectionProbe_proto = cls->getProto(); + __jsb_cc_scene_ReflectionProbe_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_PassInstance_class = nullptr; +se::Object* __jsb_cc_PassInstance_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_PassInstance) + +static bool js_new_cc_PassInstance(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::MaterialInstance *arg2 = (cc::MaterialInstance *) NULL ; + cc::PassInstance *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::PassInstance *)new cc::PassInstance(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_PassInstance, __jsb_cc_PassInstance_class, js_delete_cc_PassInstance) + +static bool js_delete_cc_PassInstance(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_PassInstance) + +static bool js_cc_PassInstance_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::PassInstance *arg1 = (cc::PassInstance *) NULL ; + cc::scene::Pass *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)cc_PassInstance_parent_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_PassInstance_parent_get) + +bool js_register_cc_PassInstance(se::Object* obj) { + auto* cls = se::Class::create("PassInstance", obj, __jsb_cc_scene_Pass_proto, _SE(js_new_cc_PassInstance)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("parent", _SE(js_cc_PassInstance_parent_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_PassInstance)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_PassInstance_proto = cls->getProto(); + __jsb_cc_PassInstance_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMaterialInstanceInfo_class = nullptr; +se::Object* __jsb_cc_IMaterialInstanceInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMaterialInstanceInfo) + +static bool js_cc_IMaterialInstanceInfo_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInstanceInfo_parent_set) + +static bool js_cc_IMaterialInstanceInfo_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInstanceInfo_parent_get) + +static bool js_cc_IMaterialInstanceInfo_subModelIdx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subModelIdx, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInstanceInfo_subModelIdx_set) + +static bool js_cc_IMaterialInstanceInfo_subModelIdx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subModelIdx, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInstanceInfo_subModelIdx_get) + +static bool js_new_cc_IMaterialInstanceInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMaterialInstanceInfo *result; + result = (cc::IMaterialInstanceInfo *)new cc::IMaterialInstanceInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMaterialInstanceInfo, __jsb_cc_IMaterialInstanceInfo_class, js_delete_cc_IMaterialInstanceInfo) + +static bool js_delete_cc_IMaterialInstanceInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMaterialInstanceInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInstanceInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("parent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->parent), ctx); + } + + + json->getProperty("subModelIdx", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subModelIdx), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMaterialInstanceInfo(se::Object* obj) { + auto* cls = se::Class::create("IMaterialInstanceInfo", obj, nullptr, _SE(js_new_cc_IMaterialInstanceInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("parent", _SE(js_cc_IMaterialInstanceInfo_parent_get), _SE(js_cc_IMaterialInstanceInfo_parent_set)); + cls->defineProperty("subModelIdx", _SE(js_cc_IMaterialInstanceInfo_subModelIdx_get), _SE(js_cc_IMaterialInstanceInfo_subModelIdx_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMaterialInstanceInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMaterialInstanceInfo_proto = cls->getProto(); + __jsb_cc_IMaterialInstanceInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MaterialInstance_class = nullptr; +se::Object* __jsb_cc_MaterialInstance_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MaterialInstance) + +static bool js_new_cc_MaterialInstance(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::IMaterialInstanceInfo *arg1 = 0 ; + cc::IMaterialInstanceInfo temp1 ; + cc::MaterialInstance *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::MaterialInstance *)new cc::MaterialInstance((cc::IMaterialInstanceInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MaterialInstance, __jsb_cc_MaterialInstance_class, js_delete_cc_MaterialInstance) + +static bool js_cc_MaterialInstance_recompileShaders__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::MacroRecord *arg2 = 0 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2); + + + return true; +} + +static bool js_cc_MaterialInstance_recompileShaders__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::MacroRecord *arg2 = 0 ; + index_t arg3 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_MaterialInstance_recompileShaders(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_MaterialInstance_recompileShaders__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MaterialInstance_recompileShaders__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MaterialInstance_recompileShaders) + +static bool js_cc_MaterialInstance_overridePipelineStates__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::PassOverrides *arg2 = 0 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2); + + + return true; +} + +static bool js_cc_MaterialInstance_overridePipelineStates__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::PassOverrides *arg2 = 0 ; + index_t arg3 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_MaterialInstance_overridePipelineStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_MaterialInstance_overridePipelineStates__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MaterialInstance_overridePipelineStates__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MaterialInstance_overridePipelineStates) + +static bool js_cc_MaterialInstance_onPassStateChange(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->onPassStateChange(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MaterialInstance_onPassStateChange) + +static bool js_cc_MaterialInstance_setRebuildPSOCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::MaterialInstance::RebuildPSOCallback *arg2 = 0 ; + cc::MaterialInstance::RebuildPSOCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setRebuildPSOCallback((cc::MaterialInstance::RebuildPSOCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MaterialInstance_setRebuildPSOCallback) + +static bool js_delete_cc_MaterialInstance(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MaterialInstance) + +bool js_register_cc_MaterialInstance(se::Object* obj) { + auto* cls = se::Class::create("MaterialInstance", obj, __jsb_cc_Material_proto, _SE(js_new_cc_MaterialInstance)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("recompileShaders", _SE(js_cc_MaterialInstance_recompileShaders)); + cls->defineFunction("overridePipelineStates", _SE(js_cc_MaterialInstance_overridePipelineStates)); + cls->defineFunction("onPassStateChange", _SE(js_cc_MaterialInstance_onPassStateChange)); + cls->defineFunction("setRebuildPSOCallback", _SE(js_cc_MaterialInstance_setRebuildPSOCallback)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MaterialInstance)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MaterialInstance_proto = cls->getProto(); + __jsb_cc_MaterialInstance_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphModel_class = nullptr; +se::Object* __jsb_cc_MorphModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphModel) + +static bool js_new_cc_MorphModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MorphModel *result; + result = (cc::MorphModel *)new cc::MorphModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MorphModel, __jsb_cc_MorphModel_class, js_delete_cc_MorphModel) + +static bool js_delete_cc_MorphModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphModel) + +static bool js_cc_MorphModel_setMorphRendering(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphModel *arg1 = (cc::MorphModel *) NULL ; + cc::MorphRenderingInstance *arg2 = (cc::MorphRenderingInstance *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMorphRendering(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphModel_setMorphRendering) + +bool js_register_cc_MorphModel(se::Object* obj) { + auto* cls = se::Class::create("MorphModel", obj, __jsb_cc_scene_Model_proto, _SE(js_new_cc_MorphModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setMorphRendering", _SE(js_cc_MorphModel_setMorphRendering)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphModel_proto = cls->getProto(); + __jsb_cc_MorphModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkinningModel_class = nullptr; +se::Object* __jsb_cc_SkinningModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkinningModel) + +static bool js_new_cc_SkinningModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkinningModel *result; + result = (cc::SkinningModel *)new cc::SkinningModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkinningModel, __jsb_cc_SkinningModel_class, js_delete_cc_SkinningModel) + +static bool js_delete_cc_SkinningModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkinningModel) + +static bool js_cc_SkinningModel_bindSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkinningModel *arg1 = (cc::SkinningModel *) NULL ; + cc::Skeleton *arg2 = (cc::Skeleton *) NULL ; + cc::Node *arg3 = (cc::Node *) NULL ; + cc::Mesh *arg4 = (cc::Mesh *) NULL ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindSkeleton(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_SkinningModel_bindSkeleton) + +bool js_register_cc_SkinningModel(se::Object* obj) { + auto* cls = se::Class::create("SkinningModel", obj, __jsb_cc_MorphModel_proto, _SE(js_new_cc_SkinningModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("bindSkeleton", _SE(js_cc_SkinningModel_bindSkeleton)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkinningModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkinningModel_proto = cls->getProto(); + __jsb_cc_SkinningModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BakedSkinningModel_class = nullptr; +se::Object* __jsb_cc_BakedSkinningModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BakedSkinningModel) + +static bool js_new_cc_BakedSkinningModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BakedSkinningModel *result; + result = (cc::BakedSkinningModel *)new cc::BakedSkinningModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BakedSkinningModel, __jsb_cc_BakedSkinningModel_class, js_delete_cc_BakedSkinningModel) + +static bool js_delete_cc_BakedSkinningModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BakedSkinningModel) + +static bool js_cc_BakedSkinningModel_updateInstancedJointTextureInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateInstancedJointTextureInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_updateInstancedJointTextureInfo) + +static bool js_cc_BakedSkinningModel_bindSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + cc::Skeleton *arg2 = (cc::Skeleton *) NULL ; + cc::Node *arg3 = (cc::Node *) NULL ; + cc::Mesh *arg4 = (cc::Mesh *) NULL ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindSkeleton(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_bindSkeleton) + +static bool js_cc_BakedSkinningModel_updateModelBounds(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateModelBounds(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_updateModelBounds) + +static bool js_cc_BakedSkinningModel_syncAnimInfoForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + cc::Float32Array *arg3 = 0 ; + cc::Uint8Array *arg4 = 0 ; + cc::Float32Array temp3 ; + cc::Uint8Array temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->syncAnimInfoForJS(arg2,(cc::Float32Array const &)*arg3,*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_syncAnimInfoForJS) + +static bool js_cc_BakedSkinningModel_syncDataForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + ccstd::vector< ccstd::optional< cc::geometry::AABB > > *arg2 = 0 ; + ccstd::optional< cc::geometry::AABB > *arg3 = 0 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + cc::gfx::Texture *arg8 = (cc::gfx::Texture *) NULL ; + cc::Float32Array *arg9 = 0 ; + ccstd::vector< ccstd::optional< cc::geometry::AABB > > temp2 ; + ccstd::optional< cc::geometry::AABB > temp3 ; + cc::Float32Array temp9 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &temp9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg9 = &temp9; + + (arg1)->syncDataForJS((ccstd::vector< ccstd::optional< cc::geometry::AABB > > const &)*arg2,(ccstd::optional< cc::geometry::AABB > const &)*arg3,arg4,arg5,arg6,arg7,arg8,(cc::Float32Array const &)*arg9); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_syncDataForJS) + +static bool js_cc_BakedSkinningModel_setUploadedAnimForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUploadedAnimForJS(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_setUploadedAnimForJS) + +bool js_register_cc_BakedSkinningModel(se::Object* obj) { + auto* cls = se::Class::create("BakedSkinningModel", obj, __jsb_cc_MorphModel_proto, _SE(js_new_cc_BakedSkinningModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateInstancedJointTextureInfo", _SE(js_cc_BakedSkinningModel_updateInstancedJointTextureInfo)); + cls->defineFunction("bindSkeleton", _SE(js_cc_BakedSkinningModel_bindSkeleton)); + cls->defineFunction("updateModelBounds", _SE(js_cc_BakedSkinningModel_updateModelBounds)); + cls->defineFunction("syncAnimInfoForJS", _SE(js_cc_BakedSkinningModel_syncAnimInfoForJS)); + cls->defineFunction("syncDataForJS", _SE(js_cc_BakedSkinningModel_syncDataForJS)); + cls->defineFunction("setUploadedAnimForJS", _SE(js_cc_BakedSkinningModel_setUploadedAnimForJS)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BakedSkinningModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BakedSkinningModel_proto = cls->getProto(); + __jsb_cc_BakedSkinningModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDefineRecord_class = nullptr; +se::Object* __jsb_cc_IDefineRecord_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDefineRecord) + +static bool js_cc_IDefineRecord_map_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->map, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineRecord_map_set) + +static bool js_cc_IDefineRecord_map_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->map, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->map, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineRecord_map_get) + +static bool js_cc_IDefineRecord_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineRecord_offset_set) + +static bool js_cc_IDefineRecord_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineRecord_offset_get) + +static bool js_new_cc_IDefineRecord(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDefineRecord *result; + result = (cc::IDefineRecord *)new cc::IDefineRecord(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDefineRecord, __jsb_cc_IDefineRecord_class, js_delete_cc_IDefineRecord) + +static bool js_delete_cc_IDefineRecord(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDefineRecord) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineRecord * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("map", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->map), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDefineRecord(se::Object* obj) { + auto* cls = se::Class::create("IDefineRecord", obj, __jsb_cc_IDefineInfo_proto, _SE(js_new_cc_IDefineRecord)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("map", _SE(js_cc_IDefineRecord_map_get), _SE(js_cc_IDefineRecord_map_set)); + cls->defineProperty("offset", _SE(js_cc_IDefineRecord_offset_get), _SE(js_cc_IDefineRecord_offset_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDefineRecord)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDefineRecord_proto = cls->getProto(); + __jsb_cc_IDefineRecord_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMacroInfo_class = nullptr; +se::Object* __jsb_cc_IMacroInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMacroInfo) + +static bool js_cc_IMacroInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMacroInfo_name_set) + +static bool js_cc_IMacroInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMacroInfo_name_get) + +static bool js_cc_IMacroInfo_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMacroInfo_value_set) + +static bool js_cc_IMacroInfo_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->value, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMacroInfo_value_get) + +static bool js_cc_IMacroInfo_isDefault_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDefault); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMacroInfo_isDefault_set) + +static bool js_cc_IMacroInfo_isDefault_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDefault, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMacroInfo_isDefault_get) + +static bool js_new_cc_IMacroInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMacroInfo *result; + result = (cc::IMacroInfo *)new cc::IMacroInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMacroInfo, __jsb_cc_IMacroInfo_class, js_delete_cc_IMacroInfo) + +static bool js_delete_cc_IMacroInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMacroInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMacroInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + json->getProperty("isDefault", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDefault), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMacroInfo(se::Object* obj) { + auto* cls = se::Class::create("IMacroInfo", obj, nullptr, _SE(js_new_cc_IMacroInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IMacroInfo_name_get), _SE(js_cc_IMacroInfo_name_set)); + cls->defineProperty("value", _SE(js_cc_IMacroInfo_value_get), _SE(js_cc_IMacroInfo_value_set)); + cls->defineProperty("isDefault", _SE(js_cc_IMacroInfo_isDefault_get), _SE(js_cc_IMacroInfo_isDefault_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMacroInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMacroInfo_proto = cls->getProto(); + __jsb_cc_IMacroInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IProgramInfo_class = nullptr; +se::Object* __jsb_cc_IProgramInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IProgramInfo) + +static bool js_cc_IProgramInfo_effectName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->effectName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_effectName_set) + +static bool js_cc_IProgramInfo_effectName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->effectName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->effectName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_effectName_get) + +static bool js_cc_IProgramInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_defines_set) + +static bool js_cc_IProgramInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_defines_get) + +static bool js_cc_IProgramInfo_constantMacros_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->constantMacros, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_constantMacros_set) + +static bool js_cc_IProgramInfo_constantMacros_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->constantMacros, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->constantMacros, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_constantMacros_get) + +static bool js_cc_IProgramInfo_uber_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uber); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_uber_set) + +static bool js_cc_IProgramInfo_uber_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uber, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_uber_get) + +static bool js_cc_IProgramInfo_copyFrom(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + cc::IShaderInfo *arg2 = 0 ; + cc::IShaderInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->copyFrom((cc::IShaderInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_IProgramInfo_copyFrom) + +static bool js_new_cc_IProgramInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IProgramInfo *result; + result = (cc::IProgramInfo *)new cc::IProgramInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IProgramInfo, __jsb_cc_IProgramInfo_class, js_delete_cc_IProgramInfo) + +static bool js_delete_cc_IProgramInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IProgramInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IProgramInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("effectName", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->effectName), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("constantMacros", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->constantMacros), ctx); + } + + + json->getProperty("uber", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uber), ctx); + } + + + return ok; +} + + +bool js_register_cc_IProgramInfo(se::Object* obj) { + auto* cls = se::Class::create("IProgramInfo", obj, __jsb_cc_IShaderInfo_proto, _SE(js_new_cc_IProgramInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("effectName", _SE(js_cc_IProgramInfo_effectName_get), _SE(js_cc_IProgramInfo_effectName_set)); + cls->defineProperty("defines", _SE(js_cc_IProgramInfo_defines_get), _SE(js_cc_IProgramInfo_defines_set)); + cls->defineProperty("constantMacros", _SE(js_cc_IProgramInfo_constantMacros_get), _SE(js_cc_IProgramInfo_constantMacros_set)); + cls->defineProperty("uber", _SE(js_cc_IProgramInfo_uber_get), _SE(js_cc_IProgramInfo_uber_set)); + + cls->defineFunction("copyFrom", _SE(js_cc_IProgramInfo_copyFrom)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IProgramInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IProgramInfo_proto = cls->getProto(); + __jsb_cc_IProgramInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_getDeviceShaderVersion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + char *result = 0 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (char *)cc::getDeviceShaderVersion((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_FUNC(js_cc_getDeviceShaderVersion) + +se::Class* __jsb_cc_ProgramLib_class = nullptr; +se::Object* __jsb_cc_ProgramLib_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ProgramLib) + +static bool js_cc_ProgramLib_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::ProgramLib *)cc::ProgramLib::getInstance(); + + 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_ProgramLib_getInstance_static) + +static bool js_new_cc_ProgramLib(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ProgramLib *result; + result = (cc::ProgramLib *)new cc::ProgramLib(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ProgramLib, __jsb_cc_ProgramLib_class, js_delete_cc_ProgramLib) + +static bool js_delete_cc_ProgramLib(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ProgramLib) + +static bool js_cc_ProgramLib_cpp_keyword_register(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::EffectAsset *arg2 = (cc::EffectAsset *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->registerEffect(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_cpp_keyword_register) + +static bool js_cc_ProgramLib_define(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::IShaderInfo *arg2 = 0 ; + cc::IShaderInfo temp2 ; + cc::IProgramInfo *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(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::IProgramInfo *)(arg1)->define(*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_ProgramLib_define) + +static bool js_cc_ProgramLib_getTemplate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::IProgramInfo *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(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::IProgramInfo *)((cc::ProgramLib const *)arg1)->getTemplate((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_ProgramLib_getTemplate) + +static bool js_cc_ProgramLib_getTemplateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::ITemplateInfo *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(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::ITemplateInfo *)(arg1)->getTemplateInfo((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_ProgramLib_getTemplateInfo) + +static bool js_cc_ProgramLib_getDescriptorSetLayout__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + bool arg4 ; + ccstd::string temp3 ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout(arg2,(ccstd::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getDescriptorSetLayout__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_ProgramLib_getDescriptorSetLayout__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_ProgramLib_getDescriptorSetLayout__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_ProgramLib_getDescriptorSetLayout) + +static bool js_cc_ProgramLib_hasProgram(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) 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(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::ProgramLib const *)arg1)->hasProgram((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_hasProgram) + +static bool js_cc_ProgramLib_getKey(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + ccstd::string *arg2 = 0 ; + cc::MacroRecord *arg3 = 0 ; + ccstd::string temp2 ; + cc::MacroRecord temp3 ; + ccstd::string result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (arg1)->getKey((ccstd::string const &)*arg2,(cc::MacroRecord const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_getKey) + +static bool js_cc_ProgramLib_destroyShaderByDefines(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::MacroRecord *arg2 = 0 ; + cc::MacroRecord temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->destroyShaderByDefines((cc::MacroRecord const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_destroyShaderByDefines) + +static bool js_cc_ProgramLib_getGFXShader__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + cc::MacroRecord *arg4 = 0 ; + cc::render::PipelineRuntime *arg5 = (cc::render::PipelineRuntime *) NULL ; + ccstd::string *arg6 = (ccstd::string *) NULL ; + ccstd::string temp3 ; + cc::MacroRecord temp4 ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + 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 = (cc::gfx::Shader *)(arg1)->getGFXShader(arg2,(ccstd::string const &)*arg3,*arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getGFXShader__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + cc::MacroRecord *arg4 = 0 ; + cc::render::PipelineRuntime *arg5 = (cc::render::PipelineRuntime *) NULL ; + ccstd::string temp3 ; + cc::MacroRecord temp4 ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::Shader *)(arg1)->getGFXShader(arg2,(ccstd::string const &)*arg3,*arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getGFXShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_ProgramLib_getGFXShader__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_ProgramLib_getGFXShader__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_ProgramLib_getGFXShader) + +bool js_register_cc_ProgramLib(se::Object* obj) { + auto* cls = se::Class::create("ProgramLib", obj, nullptr, _SE(js_new_cc_ProgramLib)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("register", _SE(js_cc_ProgramLib_cpp_keyword_register)); + cls->defineFunction("define", _SE(js_cc_ProgramLib_define)); + cls->defineFunction("getTemplate", _SE(js_cc_ProgramLib_getTemplate)); + cls->defineFunction("getTemplateInfo", _SE(js_cc_ProgramLib_getTemplateInfo)); + cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_ProgramLib_getDescriptorSetLayout)); + cls->defineFunction("hasProgram", _SE(js_cc_ProgramLib_hasProgram)); + cls->defineFunction("getKey", _SE(js_cc_ProgramLib_getKey)); + cls->defineFunction("destroyShaderByDefines", _SE(js_cc_ProgramLib_destroyShaderByDefines)); + cls->defineFunction("getGFXShader", _SE(js_cc_ProgramLib_getGFXShader)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_ProgramLib_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ProgramLib)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ProgramLib_proto = cls->getProto(); + __jsb_cc_ProgramLib_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_OctreeInfo_class = nullptr; +se::Object* __jsb_cc_scene_OctreeInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_OctreeInfo) + +static bool js_new_cc_scene_OctreeInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::OctreeInfo *result; + result = (cc::scene::OctreeInfo *)new cc::scene::OctreeInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_OctreeInfo, __jsb_cc_scene_OctreeInfo_class, js_delete_cc_scene_OctreeInfo) + +static bool js_delete_cc_scene_OctreeInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_OctreeInfo) + +static bool js_cc_scene_OctreeInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::scene::Octree *arg2 = (cc::scene::Octree *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_OctreeInfo_activate) + +static bool js_cc_scene_OctreeInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__enabled_set) + +static bool js_cc_scene_OctreeInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__enabled_get) + +static bool js_cc_scene_OctreeInfo__minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_minPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__minPos_set) + +static bool js_cc_scene_OctreeInfo__minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_minPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_minPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__minPos_get) + +static bool js_cc_scene_OctreeInfo__maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_maxPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__maxPos_set) + +static bool js_cc_scene_OctreeInfo__maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_maxPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_maxPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__maxPos_get) + +static bool js_cc_scene_OctreeInfo__depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__depth_set) + +static bool js_cc_scene_OctreeInfo__depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__depth_get) + +static bool js_cc_scene_OctreeInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_OctreeInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_enabled_set) + +static bool js_cc_scene_OctreeInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_OctreeInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo_enabled_get) + +static bool js_cc_scene_OctreeInfo_minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_OctreeInfo_minPos_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_minPos_set) + +static bool js_cc_scene_OctreeInfo_minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_OctreeInfo_minPos_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_scene_OctreeInfo_minPos_get) + +static bool js_cc_scene_OctreeInfo_maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_OctreeInfo_maxPos_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_maxPos_set) + +static bool js_cc_scene_OctreeInfo_maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_OctreeInfo_maxPos_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_scene_OctreeInfo_maxPos_get) + +static bool js_cc_scene_OctreeInfo_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_OctreeInfo_depth_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_depth_set) + +static bool js_cc_scene_OctreeInfo_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_OctreeInfo_depth_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo_depth_get) + +bool js_register_cc_scene_OctreeInfo(se::Object* obj) { + auto* cls = se::Class::create("OctreeInfo", obj, nullptr, _SE(js_new_cc_scene_OctreeInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_enabled", _SE(js_cc_scene_OctreeInfo__enabled_get), _SE(js_cc_scene_OctreeInfo__enabled_set)); + cls->defineProperty("_minPos", _SE(js_cc_scene_OctreeInfo__minPos_get), _SE(js_cc_scene_OctreeInfo__minPos_set)); + cls->defineProperty("_maxPos", _SE(js_cc_scene_OctreeInfo__maxPos_get), _SE(js_cc_scene_OctreeInfo__maxPos_set)); + cls->defineProperty("_depth", _SE(js_cc_scene_OctreeInfo__depth_get), _SE(js_cc_scene_OctreeInfo__depth_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_OctreeInfo_enabled_get), _SE(js_cc_scene_OctreeInfo_enabled_set)); + cls->defineProperty("minPos", _SE(js_cc_scene_OctreeInfo_minPos_get), _SE(js_cc_scene_OctreeInfo_minPos_set)); + cls->defineProperty("maxPos", _SE(js_cc_scene_OctreeInfo_maxPos_get), _SE(js_cc_scene_OctreeInfo_maxPos_set)); + cls->defineProperty("depth", _SE(js_cc_scene_OctreeInfo_depth_get), _SE(js_cc_scene_OctreeInfo_depth_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_OctreeInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_OctreeInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_OctreeInfo_proto = cls->getProto(); + __jsb_cc_scene_OctreeInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_BBox_class = nullptr; +se::Object* __jsb_cc_scene_BBox_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_BBox) + +static bool js_cc_scene_BBox_min_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->min, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_BBox_min_set) + +static bool js_cc_scene_BBox_min_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->min, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->min, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_BBox_min_get) + +static bool js_cc_scene_BBox_max_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->max, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_BBox_max_set) + +static bool js_cc_scene_BBox_max_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->max, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->max, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_BBox_max_get) + +static bool js_new_cc_scene_BBox__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::scene::BBox *result; + result = (cc::scene::BBox *)new cc::scene::BBox(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_BBox__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::AABB *arg1 = 0 ; + cc::geometry::AABB temp1 ; + cc::scene::BBox *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::scene::BBox *)new cc::scene::BBox((cc::geometry::AABB const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_BBox__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp1 ; + cc::Vec3 temp2 ; + cc::scene::BBox *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::scene::BBox *)new cc::scene::BBox((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_BBox(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_scene_BBox__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_scene_BBox__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_scene_BBox__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of BBox"); + return false; +} +SE_BIND_CTOR(js_new_cc_scene_BBox, __jsb_cc_scene_BBox_class, js_delete_cc_scene_BBox) + +static bool js_cc_scene_BBox_getCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::BBox const *)arg1)->getCenter(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_BBox_getCenter) + +static bool js_cc_scene_BBox_contain__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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::scene::BBox const *)arg1)->contain((cc::Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_BBox_contain__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::scene::BBox *arg2 = 0 ; + cc::scene::BBox temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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::scene::BBox const *)arg1)->contain((cc::scene::BBox const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_BBox_contain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_BBox_contain__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_BBox_contain__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_BBox_contain) + +static bool js_cc_scene_BBox_intersect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::scene::BBox *arg2 = 0 ; + cc::scene::BBox 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(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::scene::BBox const *)arg1)->intersect((cc::scene::BBox const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_BBox_intersect) + +static bool js_delete_cc_scene_BBox(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_BBox) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::BBox * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("min", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->min), ctx); + } + + + json->getProperty("max", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->max), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_BBox(se::Object* obj) { + auto* cls = se::Class::create("BBox", obj, nullptr, _SE(js_new_cc_scene_BBox)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("min", _SE(js_cc_scene_BBox_min_get), _SE(js_cc_scene_BBox_min_set)); + cls->defineProperty("max", _SE(js_cc_scene_BBox_max_get), _SE(js_cc_scene_BBox_max_set)); + + cls->defineFunction("getCenter", _SE(js_cc_scene_BBox_getCenter)); + cls->defineFunction("contain", _SE(js_cc_scene_BBox_contain)); + cls->defineFunction("intersect", _SE(js_cc_scene_BBox_intersect)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_BBox)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_BBox_proto = cls->getProto(); + __jsb_cc_scene_BBox_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_OctreeNode_class = nullptr; +se::Object* __jsb_cc_scene_OctreeNode_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_OctreeNode) + +bool js_register_cc_scene_OctreeNode(se::Object* obj) { + auto* cls = se::Class::create("OctreeNode", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_OctreeNode_proto = cls->getProto(); + __jsb_cc_scene_OctreeNode_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Octree_class = nullptr; +se::Object* __jsb_cc_scene_Octree_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Octree) + +static bool js_new_cc_scene_Octree(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Octree *result; + result = (cc::scene::Octree *)new cc::scene::Octree(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Octree, __jsb_cc_scene_Octree_class, js_delete_cc_scene_Octree) + +static bool js_delete_cc_scene_Octree(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Octree) + +static bool js_cc_scene_Octree_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::OctreeInfo *arg2 = 0 ; + cc::scene::OctreeInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::OctreeInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_initialize) + +static bool js_cc_scene_Octree_setEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setEnabled) + +static bool js_cc_scene_Octree_isEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Octree const *)arg1)->isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_isEnabled) + +static bool js_cc_scene_Octree_setMinPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMinPos((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setMinPos) + +static bool js_cc_scene_Octree_getMinPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::Octree const *)arg1)->getMinPos(); + + 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_scene_Octree_getMinPos) + +static bool js_cc_scene_Octree_setMaxPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMaxPos((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setMaxPos) + +static bool js_cc_scene_Octree_getMaxPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::Octree const *)arg1)->getMaxPos(); + + 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_scene_Octree_getMaxPos) + +static bool js_cc_scene_Octree_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + uint32_t arg4 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resize((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_resize) + +static bool js_cc_scene_Octree_insert(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->insert(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_insert) + +static bool js_cc_scene_Octree_remove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->remove(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_remove) + +static bool js_cc_scene_Octree_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_update) + +static bool js_cc_scene_Octree_setMaxDepth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaxDepth(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setMaxDepth) + +static bool js_cc_scene_Octree_getMaxDepth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Octree const *)arg1)->getMaxDepth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_getMaxDepth) + +static bool js_cc_scene_Octree_queryVisibility(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::geometry::Frustum *arg3 = 0 ; + bool arg4 ; + ccstd::vector< cc::scene::Model const * > *arg5 = 0 ; + cc::geometry::Frustum temp3 ; + ccstd::vector< cc::scene::Model const * > temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + ((cc::scene::Octree const *)arg1)->queryVisibility((cc::scene::Camera const *)arg2,(cc::geometry::Frustum const &)*arg3,arg4,*arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_queryVisibility) + +bool js_register_cc_scene_Octree(se::Object* obj) { + auto* cls = se::Class::create("Octree", obj, nullptr, _SE(js_new_cc_scene_Octree)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_scene_Octree_initialize)); + cls->defineFunction("setEnabled", _SE(js_cc_scene_Octree_setEnabled)); + cls->defineFunction("isEnabled", _SE(js_cc_scene_Octree_isEnabled)); + cls->defineFunction("setMinPos", _SE(js_cc_scene_Octree_setMinPos)); + cls->defineFunction("getMinPos", _SE(js_cc_scene_Octree_getMinPos)); + cls->defineFunction("setMaxPos", _SE(js_cc_scene_Octree_setMaxPos)); + cls->defineFunction("getMaxPos", _SE(js_cc_scene_Octree_getMaxPos)); + cls->defineFunction("resize", _SE(js_cc_scene_Octree_resize)); + cls->defineFunction("insert", _SE(js_cc_scene_Octree_insert)); + cls->defineFunction("remove", _SE(js_cc_scene_Octree_remove)); + cls->defineFunction("update", _SE(js_cc_scene_Octree_update)); + cls->defineFunction("setMaxDepth", _SE(js_cc_scene_Octree_setMaxDepth)); + cls->defineFunction("getMaxDepth", _SE(js_cc_scene_Octree_getMaxDepth)); + cls->defineFunction("queryVisibility", _SE(js_cc_scene_Octree_queryVisibility)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Octree)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Octree_proto = cls->getProto(); + __jsb_cc_scene_Octree_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_scene(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_Layers(ns); + js_register_cc_Node(ns); + js_register_cc_Node_UserData(ns); + js_register_cc_Scene(ns); + js_register_cc_SceneGlobals(ns); + js_register_cc_Root(ns); + js_register_cc_scene_IMacroPatch(ns); + js_register_cc_scene_Light(ns); + js_register_cc_scene_LODData(ns); + js_register_cc_scene_LODGroup(ns); + js_register_cc_scene_Fog(ns); + js_register_cc_scene_FogInfo(ns); + js_register_cc_scene_ShadowsInfo(ns); + js_register_cc_scene_Shadows(ns); + js_register_cc_scene_SkyboxInfo(ns); + js_register_cc_scene_Skybox(ns); + js_register_cc_scene_SkinInfo(ns); + js_register_cc_scene_Skin(ns); + js_register_cc_scene_PostSettingsInfo(ns); + js_register_cc_scene_PostSettings(ns); + js_register_cc_scene_DirectionalLight(ns); + js_register_cc_scene_SpotLight(ns); + js_register_cc_scene_SphereLight(ns); + js_register_cc_scene_PointLight(ns); + js_register_cc_scene_RangedDirectionalLight(ns); + js_register_cc_scene_Model(ns); + js_register_cc_scene_InstancedAttributeBlock(ns); + js_register_cc_scene_SubModel(ns); + js_register_cc_scene_PassDynamicsValue(ns); + js_register_cc_scene_IBlockRef(ns); + js_register_cc_scene_Pass(ns); + js_register_cc_scene_IRaycastResult(ns); + js_register_cc_scene_IRenderSceneInfo(ns); + js_register_cc_scene_RenderScene(ns); + js_register_cc_scene_IRenderWindowInfo(ns); + js_register_cc_scene_RenderWindow(ns); + js_register_cc_scene_ICameraInfo(ns); + js_register_cc_scene_Camera(ns); + js_register_cc_scene_Ambient(ns); + js_register_cc_scene_AmbientInfo(ns); + js_register_cc_scene_ReflectionProbe(ns); + js_register_cc_PassInstance(ns); + js_register_cc_IMaterialInstanceInfo(ns); + js_register_cc_MaterialInstance(ns); + js_register_cc_MorphModel(ns); + js_register_cc_SkinningModel(ns); + js_register_cc_BakedSkinningModel(ns); + js_register_cc_IDefineRecord(ns); + js_register_cc_IMacroInfo(ns); + js_register_cc_IProgramInfo(ns); + js_register_cc_ProgramLib(ns); + js_register_cc_scene_OctreeInfo(ns); + js_register_cc_scene_BBox(ns); + js_register_cc_scene_OctreeNode(ns); + js_register_cc_scene_Octree(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_scene_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_scene_auto.h new file mode 100644 index 0000000000..060b676852 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_scene_auto.h @@ -0,0 +1,404 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/auto/jsb_gi_auto.h" +#include "core/Root.h" +#include "core/scene-graph/Node.h" +#include "core/scene-graph/Scene.h" +#include "core/scene-graph/SceneGlobals.h" +#include "scene/Light.h" +#include "scene/LODGroup.h" +#include "scene/Fog.h" +#include "scene/Shadow.h" +#include "scene/Skybox.h" +#include "scene/Skin.h" +#include "scene/PostSettings.h" +#include "scene/DirectionalLight.h" +#include "scene/SpotLight.h" +#include "scene/SphereLight.h" +#include "scene/PointLight.h" +#include "scene/RangedDirectionalLight.h" +#include "scene/Model.h" +#include "scene/SubModel.h" +#include "scene/Pass.h" +#include "scene/RenderScene.h" +#include "scene/DrawBatch2D.h" +#include "scene/RenderWindow.h" +#include "scene/Camera.h" +#include "scene/Define.h" +#include "scene/Ambient.h" +#include "renderer/core/PassInstance.h" +#include "renderer/core/MaterialInstance.h" +#include "3d/models/MorphModel.h" +#include "3d/models/SkinningModel.h" +#include "3d/models/BakedSkinningModel.h" +#include "renderer/core/ProgramLib.h" +#include "scene/Octree.h" +#include "scene/ReflectionProbe.h" + + + +bool register_all_scene(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::Layers); +extern se::Object *__jsb_cc_Layers_proto; // NOLINT +extern se::Class * __jsb_cc_Layers_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Node::UserData); +extern se::Object *__jsb_cc_Node_UserData_proto; // NOLINT +extern se::Class * __jsb_cc_Node_UserData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Node); +extern se::Object *__jsb_cc_Node_proto; // NOLINT +extern se::Class * __jsb_cc_Node_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Scene); +extern se::Object *__jsb_cc_Scene_proto; // NOLINT +extern se::Class * __jsb_cc_Scene_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SceneGlobals); +extern se::Object *__jsb_cc_SceneGlobals_proto; // NOLINT +extern se::Class * __jsb_cc_SceneGlobals_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Root); +extern se::Object *__jsb_cc_Root_proto; // NOLINT +extern se::Class * __jsb_cc_Root_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IMacroPatch); +extern se::Object *__jsb_cc_scene_IMacroPatch_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IMacroPatch_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IMacroPatch * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Light); +extern se::Object *__jsb_cc_scene_Light_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Light_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::LODData); +extern se::Object *__jsb_cc_scene_LODData_proto; // NOLINT +extern se::Class * __jsb_cc_scene_LODData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::LODGroup); +extern se::Object *__jsb_cc_scene_LODGroup_proto; // NOLINT +extern se::Class * __jsb_cc_scene_LODGroup_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Fog); +extern se::Object *__jsb_cc_scene_Fog_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Fog_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::FogInfo); +extern se::Object *__jsb_cc_scene_FogInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_FogInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::ShadowsInfo); +extern se::Object *__jsb_cc_scene_ShadowsInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_ShadowsInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Shadows); +extern se::Object *__jsb_cc_scene_Shadows_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Shadows_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SkyboxInfo); +extern se::Object *__jsb_cc_scene_SkyboxInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SkyboxInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Skybox); +extern se::Object *__jsb_cc_scene_Skybox_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Skybox_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SkinInfo); +extern se::Object *__jsb_cc_scene_SkinInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SkinInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Skin); +extern se::Object *__jsb_cc_scene_Skin_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Skin_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PostSettingsInfo); +extern se::Object *__jsb_cc_scene_PostSettingsInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PostSettingsInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PostSettings); +extern se::Object *__jsb_cc_scene_PostSettings_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PostSettings_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::DirectionalLight); +extern se::Object *__jsb_cc_scene_DirectionalLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_DirectionalLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SpotLight); +extern se::Object *__jsb_cc_scene_SpotLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SpotLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SphereLight); +extern se::Object *__jsb_cc_scene_SphereLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SphereLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PointLight); +extern se::Object *__jsb_cc_scene_PointLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PointLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::RangedDirectionalLight); +extern se::Object *__jsb_cc_scene_RangedDirectionalLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_RangedDirectionalLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Model); +extern se::Object *__jsb_cc_scene_Model_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Model_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::InstancedAttributeBlock); +extern se::Object *__jsb_cc_scene_InstancedAttributeBlock_proto; // NOLINT +extern se::Class * __jsb_cc_scene_InstancedAttributeBlock_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::InstancedAttributeBlock * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SubModel); +extern se::Object *__jsb_cc_scene_SubModel_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SubModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PassDynamicsValue); +extern se::Object *__jsb_cc_scene_PassDynamicsValue_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PassDynamicsValue_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::PassDynamicsValue * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IBlockRef); +extern se::Object *__jsb_cc_scene_IBlockRef_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IBlockRef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IBlockRef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Pass); +extern se::Object *__jsb_cc_scene_Pass_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Pass_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IRaycastResult); +extern se::Object *__jsb_cc_scene_IRaycastResult_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IRaycastResult_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRaycastResult * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IRenderSceneInfo); +extern se::Object *__jsb_cc_scene_IRenderSceneInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IRenderSceneInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderSceneInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::RenderScene); +extern se::Object *__jsb_cc_scene_RenderScene_proto; // NOLINT +extern se::Class * __jsb_cc_scene_RenderScene_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IRenderWindowInfo); +extern se::Object *__jsb_cc_scene_IRenderWindowInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IRenderWindowInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderWindowInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::RenderWindow); +extern se::Object *__jsb_cc_scene_RenderWindow_proto; // NOLINT +extern se::Class * __jsb_cc_scene_RenderWindow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::ICameraInfo); +extern se::Object *__jsb_cc_scene_ICameraInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_ICameraInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::ICameraInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Camera); +extern se::Object *__jsb_cc_scene_Camera_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Camera_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Ambient); +extern se::Object *__jsb_cc_scene_Ambient_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Ambient_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::AmbientInfo); +extern se::Object *__jsb_cc_scene_AmbientInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_AmbientInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::ReflectionProbe); +extern se::Object *__jsb_cc_scene_ReflectionProbe_proto; // NOLINT +extern se::Class * __jsb_cc_scene_ReflectionProbe_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::PassInstance); +extern se::Object *__jsb_cc_PassInstance_proto; // NOLINT +extern se::Class * __jsb_cc_PassInstance_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMaterialInstanceInfo); +extern se::Object *__jsb_cc_IMaterialInstanceInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IMaterialInstanceInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInstanceInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MaterialInstance); +extern se::Object *__jsb_cc_MaterialInstance_proto; // NOLINT +extern se::Class * __jsb_cc_MaterialInstance_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphModel); +extern se::Object *__jsb_cc_MorphModel_proto; // NOLINT +extern se::Class * __jsb_cc_MorphModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkinningModel); +extern se::Object *__jsb_cc_SkinningModel_proto; // NOLINT +extern se::Class * __jsb_cc_SkinningModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::BakedSkinningModel); +extern se::Object *__jsb_cc_BakedSkinningModel_proto; // NOLINT +extern se::Class * __jsb_cc_BakedSkinningModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IDefineRecord); +extern se::Object *__jsb_cc_IDefineRecord_proto; // NOLINT +extern se::Class * __jsb_cc_IDefineRecord_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineRecord * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IMacroInfo); +extern se::Object *__jsb_cc_IMacroInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IMacroInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMacroInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IProgramInfo); +extern se::Object *__jsb_cc_IProgramInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IProgramInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IProgramInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ProgramLib); +extern se::Object *__jsb_cc_ProgramLib_proto; // NOLINT +extern se::Class * __jsb_cc_ProgramLib_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::OctreeInfo); +extern se::Object *__jsb_cc_scene_OctreeInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_OctreeInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::BBox); +extern se::Object *__jsb_cc_scene_BBox_proto; // NOLINT +extern se::Class * __jsb_cc_scene_BBox_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::BBox * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::OctreeNode); +extern se::Object *__jsb_cc_scene_OctreeNode_proto; // NOLINT +extern se::Class * __jsb_cc_scene_OctreeNode_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Octree); +extern se::Object *__jsb_cc_scene_Octree_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Octree_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_spine_3_8_auto.cpp b/native/build_android/generated/cocos/bindings/auto/jsb_spine_3_8_auto.cpp new file mode 100644 index 0000000000..cba78d861b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_spine_3_8_auto.cpp @@ -0,0 +1,25751 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_2d_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_spine_3_8_auto.h" +using namespace spine; + +#define SWIGINTERN static + + +#define spine_Animation_name_get(self_) self_->getName() + + +#define spine_Animation_timelines_get(self_) self_->getTimelines() + + +#define spine_Animation_duration_get(self_) self_->getDuration() +#define spine_Animation_duration_set(self_, val_) self_->setDuration(val_) + + +#define spine_RotateTimeline_boneIndex_get(self_) self_->getBoneIndex() +#define spine_RotateTimeline_boneIndex_set(self_, val_) self_->setBoneIndex(val_) + + +#define spine_RotateTimeline_frames_get(self_) self_->getFrames() + + +#define spine_ColorTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_ColorTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_ColorTimeline_frames_get(self_) self_->getFrames() + + +#define spine_TwoColorTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_TwoColorTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_AttachmentTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_AttachmentTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_AttachmentTimeline_frames_get(self_) self_->getFrames() + + +#define spine_AttachmentTimeline_attachmentNames_get(self_) self_->getAttachmentNames() + + +#define spine_DeformTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_DeformTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_DeformTimeline_frames_get(self_) self_->getFrames() + + +#define spine_DeformTimeline_frameVertices_get(self_) self_->getVertices() + + +#define spine_DeformTimeline_attachment_get(self_) self_->getAttachment() + + +#define spine_EventTimeline_frames_get(self_) self_->getFrames() + + +#define spine_EventTimeline_events_get(self_) self_->getEvents() + + +#define spine_DrawOrderTimeline_frames_get(self_) self_->getFrames() + + +#define spine_DrawOrderTimeline_drawOrders_get(self_) self_->getDrawOrders() + + +#define spine_AnimationState_data_get(self_) self_->getData() + + +#define spine_AnimationState_tracks_get(self_) self_->getTracks() + + +#define spine_AnimationState_timeScale_get(self_) self_->getTimeScale() +#define spine_AnimationState_timeScale_set(self_, val_) self_->setTimeScale(val_) + + +#define spine_TrackEntry_animation_get(self_) self_->getAnimation() + + +#define spine_TrackEntry_next_get(self_) self_->getNext() + + +#define spine_TrackEntry_mixingFrom_get(self_) self_->getMixingFrom() + + +#define spine_TrackEntry_mixingTo_get(self_) self_->getMixingTo() + + +#define spine_TrackEntry_trackIndex_get(self_) self_->getTrackIndex() + + +#define spine_TrackEntry_loop_get(self_) self_->getLoop() +#define spine_TrackEntry_loop_set(self_, val_) self_->setLoop(val_) + + +#define spine_TrackEntry_holdPrevious_get(self_) self_->getHoldPrevious() +#define spine_TrackEntry_holdPrevious_set(self_, val_) self_->setHoldPrevious(val_) + + +#define spine_TrackEntry_eventThreshold_get(self_) self_->getEventThreshold() +#define spine_TrackEntry_eventThreshold_set(self_, val_) self_->setEventThreshold(val_) + + +#define spine_TrackEntry_attachmentThreshold_get(self_) self_->getAttachmentThreshold() +#define spine_TrackEntry_attachmentThreshold_set(self_, val_) self_->setAttachmentThreshold(val_) + + +#define spine_TrackEntry_drawOrderThreshold_get(self_) self_->getDrawOrderThreshold() +#define spine_TrackEntry_drawOrderThreshold_set(self_, val_) self_->setDrawOrderThreshold(val_) + + +#define spine_TrackEntry_animationStart_get(self_) self_->getAnimationStart() +#define spine_TrackEntry_animationStart_set(self_, val_) self_->setAnimationStart(val_) + + +#define spine_TrackEntry_animationEnd_get(self_) self_->getAnimationEnd() +#define spine_TrackEntry_animationEnd_set(self_, val_) self_->setAnimationEnd(val_) + + +#define spine_TrackEntry_animationLast_get(self_) self_->getAnimationLast() +#define spine_TrackEntry_animationLast_set(self_, val_) self_->setAnimationLast(val_) + + +#define spine_TrackEntry_delay_get(self_) self_->getDelay() +#define spine_TrackEntry_delay_set(self_, val_) self_->setDelay(val_) + + +#define spine_TrackEntry_trackTime_get(self_) self_->getTrackTime() +#define spine_TrackEntry_trackTime_set(self_, val_) self_->setTrackTime(val_) + + +#define spine_TrackEntry_trackEnd_get(self_) self_->getTrackEnd() +#define spine_TrackEntry_trackEnd_set(self_, val_) self_->setTrackEnd(val_) + + +#define spine_TrackEntry_timeScale_get(self_) self_->getTimeScale() +#define spine_TrackEntry_timeScale_set(self_, val_) self_->setTimeScale(val_) + + +#define spine_TrackEntry_alpha_get(self_) self_->getAlpha() +#define spine_TrackEntry_alpha_set(self_, val_) self_->setAlpha(val_) + + +#define spine_TrackEntry_mixTime_get(self_) self_->getMixTime() +#define spine_TrackEntry_mixTime_set(self_, val_) self_->setMixTime(val_) + + +#define spine_TrackEntry_mixDuration_get(self_) self_->getMixDuration() +#define spine_TrackEntry_mixDuration_set(self_, val_) self_->setMixDuration(val_) + + +#define spine_TrackEntry_mixBlend_get(self_) self_->getMixBlend() +#define spine_TrackEntry_mixBlend_set(self_, val_) self_->setMixBlend(val_) + + +#define spine_AnimationStateData_skeletonData_get(self_) self_->getSkeletonData() + + +#define spine_AnimationStateData_defaultMix_get(self_) self_->getDefaultMix() +#define spine_AnimationStateData_defaultMix_set(self_, val_) self_->setDefaultMix(val_) + + +#define spine_Bone_data_get(self_) self_->getData() + + +#define spine_Bone_skeleton_get(self_) self_->getSkeleton() + + +#define spine_Bone_parent_get(self_) self_->getParent() + + +#define spine_Bone_children_get(self_) self_->getChildren() + + +#define spine_Bone_x_get(self_) self_->getX() +#define spine_Bone_x_set(self_, val_) self_->setX(val_) + + +#define spine_Bone_y_get(self_) self_->getY() +#define spine_Bone_y_set(self_, val_) self_->setY(val_) + + +#define spine_Bone_rotation_get(self_) self_->getRotation() +#define spine_Bone_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_Bone_scaleX_get(self_) self_->getScaleX() +#define spine_Bone_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_Bone_scaleY_get(self_) self_->getScaleY() +#define spine_Bone_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_Bone_shearX_get(self_) self_->getShearX() +#define spine_Bone_shearX_set(self_, val_) self_->setShearX(val_) + + +#define spine_Bone_shearY_get(self_) self_->getShearY() +#define spine_Bone_shearY_set(self_, val_) self_->setShearY(val_) + + +#define spine_Bone_ax_get(self_) self_->getAX() +#define spine_Bone_ax_set(self_, val_) self_->setAX(val_) + + +#define spine_Bone_ay_get(self_) self_->getAY() +#define spine_Bone_ay_set(self_, val_) self_->setAY(val_) + + +#define spine_Bone_arotation_get(self_) self_->getAppliedRotation() +#define spine_Bone_arotation_set(self_, val_) self_->setAppliedRotation(val_) + + +#define spine_Bone_ascaleX_get(self_) self_->getAScaleX() +#define spine_Bone_ascaleX_set(self_, val_) self_->setAScaleX(val_) + + +#define spine_Bone_ascaleY_get(self_) self_->getAScaleY() +#define spine_Bone_ascaleY_set(self_, val_) self_->setAScaleY(val_) + + +#define spine_Bone_ashearX_get(self_) self_->getAShearX() +#define spine_Bone_ashearX_set(self_, val_) self_->setAShearX(val_) + + +#define spine_Bone_ashearY_get(self_) self_->getAShearY() +#define spine_Bone_ashearY_set(self_, val_) self_->setAShearY(val_) + + +#define spine_Bone_appliedValid_get(self_) self_->isAppliedValid() +#define spine_Bone_appliedValid_set(self_, val_) self_->setAppliedValid(val_) + + +#define spine_Bone_a_get(self_) self_->getA() +#define spine_Bone_a_set(self_, val_) self_->setA(val_) + + +#define spine_Bone_b_get(self_) self_->getB() +#define spine_Bone_b_set(self_, val_) self_->setB(val_) + + +#define spine_Bone_c_get(self_) self_->getC() +#define spine_Bone_c_set(self_, val_) self_->setC(val_) + + +#define spine_Bone_d_get(self_) self_->getD() +#define spine_Bone_d_set(self_, val_) self_->setD(val_) + + +#define spine_Bone_worldX_get(self_) self_->getWorldX() +#define spine_Bone_worldX_set(self_, val_) self_->setWorldX(val_) + + +#define spine_Bone_worldY_get(self_) self_->getWorldY() +#define spine_Bone_worldY_set(self_, val_) self_->setWorldY(val_) + + +#define spine_Bone_active_get(self_) self_->isActive() +#define spine_Bone_active_set(self_, val_) self_->setActive(val_) + + +#define spine_BoneData_index_get(self_) self_->getIndex() + + +#define spine_BoneData_name_get(self_) self_->getName() + + +#define spine_BoneData_parent_get(self_) self_->getParent() + + +#define spine_BoneData_length_get(self_) self_->getLength() +#define spine_BoneData_length_set(self_, val_) self_->setLength(val_) + + +#define spine_BoneData_x_get(self_) self_->getX() +#define spine_BoneData_x_set(self_, val_) self_->setX(val_) + + +#define spine_BoneData_y_get(self_) self_->getY() +#define spine_BoneData_y_set(self_, val_) self_->setY(val_) + + +#define spine_BoneData_rotation_get(self_) self_->getRotation() +#define spine_BoneData_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_BoneData_scaleX_get(self_) self_->getScaleX() +#define spine_BoneData_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_BoneData_scaleY_get(self_) self_->getScaleY() +#define spine_BoneData_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_BoneData_shearX_get(self_) self_->getShearX() +#define spine_BoneData_shearX_set(self_, val_) self_->setShearX(val_) + + +#define spine_BoneData_shearY_get(self_) self_->getShearY() +#define spine_BoneData_shearY_set(self_, val_) self_->setShearY(val_) + + +#define spine_BoneData_transformMode_get(self_) self_->getTransformMode() +#define spine_BoneData_transformMode_set(self_, val_) self_->setTransformMode(val_) + + +#define spine_BoneData_skinRequired_get(self_) self_->isSkinRequired() +#define spine_BoneData_skinRequired_set(self_, val_) self_->setSkinRequired(val_) + + +#define spine_ConstraintData_name_get(self_) self_->getName() + + +#define spine_ConstraintData_order_get(self_) self_->getOrder() +#define spine_ConstraintData_order_set(self_, val_) self_->setOrder(val_) + + +#define spine_ConstraintData_skinRequired_get(self_) self_->isSkinRequired() +#define spine_ConstraintData_skinRequired_set(self_, val_) self_->setSkinRequired(val_) + + +#define spine_Event_data_get(self_) self_->getData() + + +#define spine_Event_intValue_get(self_) self_->getIntValue() +#define spine_Event_intValue_set(self_, val_) self_->setIntValue(val_) + + +#define spine_Event_floatValue_get(self_) self_->getFloatValue() +#define spine_Event_floatValue_set(self_, val_) self_->setFloatValue(val_) + + +#define spine_Event_stringValue_get(self_) self_->getStringValue() +#define spine_Event_stringValue_set(self_, val_) self_->setStringValue(val_) + + +#define spine_Event_time_get(self_) self_->getTime() + + +#define spine_Event_volume_get(self_) self_->getVolume() +#define spine_Event_volume_set(self_, val_) self_->setVolume(val_) + + +#define spine_Event_balance_get(self_) self_->getBalance() +#define spine_Event_balance_set(self_, val_) self_->setBalance(val_) + + +#define spine_EventData_name_get(self_) self_->getName() + + +#define spine_EventData_intValue_get(self_) self_->getIntValue() +#define spine_EventData_intValue_set(self_, val_) self_->setIntValue(val_) + + +#define spine_EventData_floatValue_get(self_) self_->getFloatValue() +#define spine_EventData_floatValue_set(self_, val_) self_->setFloatValue(val_) + + +#define spine_EventData_stringValue_get(self_) self_->getStringValue() +#define spine_EventData_stringValue_set(self_, val_) self_->setStringValue(val_) + + +#define spine_EventData_volume_get(self_) self_->getVolume() +#define spine_EventData_volume_set(self_, val_) self_->setVolume(val_) + + +#define spine_EventData_balance_get(self_) self_->getBalance() +#define spine_EventData_balance_set(self_, val_) self_->setBalance(val_) + + +#define spine_EventData_audioPath_get(self_) self_->getAudioPath() +#define spine_EventData_audioPath_set(self_, val_) self_->setAudioPath(val_) + + +#define spine_IkConstraint_data_get(self_) self_->getData() + + +#define spine_IkConstraint_bones_get(self_) self_->getBones() + + +#define spine_IkConstraint_target_get(self_) self_->getTarget() +#define spine_IkConstraint_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_IkConstraint_bendDirection_get(self_) self_->getBendDirection() +#define spine_IkConstraint_bendDirection_set(self_, val_) self_->setBendDirection(val_) + + +#define spine_IkConstraint_compress_get(self_) self_->getCompress() +#define spine_IkConstraint_compress_set(self_, val_) self_->setCompress(val_) + + +#define spine_IkConstraint_stretch_get(self_) self_->getStretch() +#define spine_IkConstraint_stretch_set(self_, val_) self_->setStretch(val_) + + +#define spine_IkConstraint_mix_get(self_) self_->getMix() +#define spine_IkConstraint_mix_set(self_, val_) self_->setMix(val_) + + +#define spine_IkConstraint_softness_get(self_) self_->getSoftness() +#define spine_IkConstraint_softness_set(self_, val_) self_->setSoftness(val_) + + +#define spine_IkConstraint_active_get(self_) self_->isActive() +#define spine_IkConstraint_active_set(self_, val_) self_->setActive(val_) + + +#define spine_IkConstraintData_bones_get(self_) self_->getBones() + + +#define spine_IkConstraintData_target_get(self_) self_->getTarget() + + +#define spine_IkConstraintData_bendDirection_get(self_) self_->getBendDirection() +#define spine_IkConstraintData_bendDirection_set(self_, val_) self_->setBendDirection(val_) + + +#define spine_IkConstraintData_compress_get(self_) self_->getCompress() +#define spine_IkConstraintData_compress_set(self_, val_) self_->setCompress(val_) + + +#define spine_IkConstraintData_stretch_get(self_) self_->getStretch() +#define spine_IkConstraintData_stretch_set(self_, val_) self_->setStretch(val_) + + +#define spine_IkConstraintData_uniform_get(self_) self_->getUniform() +#define spine_IkConstraintData_uniform_set(self_, val_) self_->setUniform(val_) + + +#define spine_IkConstraintData_mix_get(self_) self_->getMix() +#define spine_IkConstraintData_mix_set(self_, val_) self_->setMix(val_) + + +#define spine_IkConstraintData_softness_get(self_) self_->getSoftness() +#define spine_IkConstraintData_softness_set(self_, val_) self_->setSoftness(val_) + + +#define spine_PathConstraint_data_get(self_) self_->getData() + + +#define spine_PathConstraint_bones_get(self_) self_->getBones() + + +#define spine_PathConstraint_target_get(self_) self_->getTarget() +#define spine_PathConstraint_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_PathConstraint_position_get(self_) self_->getPosition() +#define spine_PathConstraint_position_set(self_, val_) self_->setPosition(val_) + + +#define spine_PathConstraint_spacing_get(self_) self_->getSpacing() +#define spine_PathConstraint_spacing_set(self_, val_) self_->setSpacing(val_) + + +#define spine_PathConstraint_rotateMix_get(self_) self_->getRotateMix() +#define spine_PathConstraint_rotateMix_set(self_, val_) self_->setRotateMix(val_) + + +#define spine_PathConstraint_translateMix_get(self_) self_->getTranslateMix() +#define spine_PathConstraint_translateMix_set(self_, val_) self_->setTranslateMix(val_) + + +#define spine_PathConstraint_active_get(self_) self_->isActive() +#define spine_PathConstraint_active_set(self_, val_) self_->setActive(val_) + + +#define spine_PathConstraintData_bones_get(self_) self_->getBones() + + +#define spine_PathConstraintData_target_get(self_) self_->getTarget() +#define spine_PathConstraintData_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_PathConstraintData_positionMode_get(self_) self_->getPositionMode() +#define spine_PathConstraintData_positionMode_set(self_, val_) self_->setPositionMode(val_) + + +#define spine_PathConstraintData_spacingMode_get(self_) self_->getSpacingMode() +#define spine_PathConstraintData_spacingMode_set(self_, val_) self_->setSpacingMode(val_) + + +#define spine_PathConstraintData_rotateMode_get(self_) self_->getRotateMode() +#define spine_PathConstraintData_rotateMode_set(self_, val_) self_->setRotateMode(val_) + + +#define spine_PathConstraintData_offsetRotation_get(self_) self_->getOffsetRotation() +#define spine_PathConstraintData_offsetRotation_set(self_, val_) self_->setOffsetRotation(val_) + + +#define spine_PathConstraintData_position_get(self_) self_->getPosition() +#define spine_PathConstraintData_position_set(self_, val_) self_->setPosition(val_) + + +#define spine_PathConstraintData_spacing_get(self_) self_->getSpacing() +#define spine_PathConstraintData_spacing_set(self_, val_) self_->setSpacing(val_) + + +#define spine_PathConstraintData_rotateMix_get(self_) self_->getRotateMix() +#define spine_PathConstraintData_rotateMix_set(self_, val_) self_->setRotateMix(val_) + + +#define spine_PathConstraintData_translateMix_get(self_) self_->getTranslateMix() +#define spine_PathConstraintData_translateMix_set(self_, val_) self_->setTranslateMix(val_) + + +#define spine_Skeleton_data_get(self_) self_->getData() + + +#define spine_Skeleton_bones_get(self_) self_->getBones() + + +#define spine_Skeleton_slots_get(self_) self_->getSlots() + + +#define spine_Skeleton_drawOrder_get(self_) self_->getDrawOrder() + + +#define spine_Skeleton_ikConstraints_get(self_) self_->getIkConstraints() + + +#define spine_Skeleton_transformConstraints_get(self_) self_->getTransformConstraints() + + +#define spine_Skeleton_pathConstraints_get(self_) self_->getPathConstraints() + + +#define spine_Skeleton__updateCache_get(self_) self_->getUpdateCacheList() + + +#define spine_Skeleton_skin_get(self_) self_->getSkin() +#define spine_Skeleton_skin_set(self_, val_) self_->setSkin(val_) + + +#define spine_Skeleton_color_get(self_) self_->getColor() + + +#define spine_Skeleton_time_get(self_) self_->getTime() +#define spine_Skeleton_time_set(self_, val_) self_->setTime(val_) + + +#define spine_Skeleton_scaleX_get(self_) self_->getScaleX() +#define spine_Skeleton_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_Skeleton_scaleY_get(self_) self_->getScaleY() +#define spine_Skeleton_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_Skeleton_x_get(self_) self_->getX() +#define spine_Skeleton_x_set(self_, val_) self_->setX(val_) + + +#define spine_Skeleton_y_get(self_) self_->getY() +#define spine_Skeleton_y_set(self_, val_) self_->setY(val_) + + +#define spine_SkeletonBinary_scale_set(self_, val_) self_->setScale(val_) + + +#define spine_SkeletonClipping_clippedVertices_get(self_) self_->getClippedVertices() + + +#define spine_SkeletonClipping_clippedTriangles_get(self_) self_->getClippedTriangles() + + +#define spine_SkeletonData_name_get(self_) self_->getName() +#define spine_SkeletonData_name_set(self_, val_) self_->setName(val_) + + +#define spine_SkeletonData_bones_get(self_) self_->getBones() + + +#define spine_SkeletonData_slots_get(self_) self_->getSlots() + + +#define spine_SkeletonData_skins_get(self_) self_->getSkins() + + +#define spine_SkeletonData_defaultSkin_get(self_) self_->getDefaultSkin() +#define spine_SkeletonData_defaultSkin_set(self_, val_) self_->setDefaultSkin(val_) + + +#define spine_SkeletonData_events_get(self_) self_->getEvents() + + +#define spine_SkeletonData_animations_get(self_) self_->getAnimations() + + +#define spine_SkeletonData_ikConstraints_get(self_) self_->getIkConstraints() + + +#define spine_SkeletonData_transformConstraints_get(self_) self_->getTransformConstraints() + + +#define spine_SkeletonData_pathConstraints_get(self_) self_->getPathConstraints() + + +#define spine_SkeletonData_x_get(self_) self_->getX() +#define spine_SkeletonData_x_set(self_, val_) self_->setX(val_) + + +#define spine_SkeletonData_y_get(self_) self_->getY() +#define spine_SkeletonData_y_set(self_, val_) self_->setY(val_) + + +#define spine_SkeletonData_width_get(self_) self_->getWidth() +#define spine_SkeletonData_width_set(self_, val_) self_->setWidth(val_) + + +#define spine_SkeletonData_height_get(self_) self_->getHeight() +#define spine_SkeletonData_height_set(self_, val_) self_->setHeight(val_) + + +#define spine_SkeletonData_version_get(self_) self_->getVersion() +#define spine_SkeletonData_version_set(self_, val_) self_->setVersion(val_) + + +#define spine_SkeletonData_hash_get(self_) self_->getHash() +#define spine_SkeletonData_hash_set(self_, val_) self_->setHash(val_) + + +#define spine_SkeletonData_fps_get(self_) self_->getFps() +#define spine_SkeletonData_fps_set(self_, val_) self_->setFps(val_) + + +#define spine_SkeletonData_imagesPath_get(self_) self_->getImagesPath() +#define spine_SkeletonData_imagesPath_set(self_, val_) self_->setImagesPath(val_) + + +#define spine_SkeletonData_audioPath_get(self_) self_->getAudioPath() +#define spine_SkeletonData_audioPath_set(self_, val_) self_->setAudioPath(val_) + + +#define spine_SkeletonJson_scale_get(self_) self_->setScale() + + +#define spine_Skin_name_get(self_) self_->getName() + + +#define spine_Skin_bones_get(self_) self_->getBones() + + +#define spine_Skin_constraints_get(self_) self_->getConstraints() + + +#define spine_Slot_data_get(self_) self_->getData() + + +#define spine_Slot_bone_get(self_) self_->getBone() + + +#define spine_Slot_color_get(self_) self_->getColor() + + +#define spine_Slot_darkColor_get(self_) self_->getDarkColor() + + +#define spine_Slot_attachment_get(self_) self_->getAttachment() +#define spine_Slot_attachment_set(self_, val_) self_->setAttachment(val_) + + +#define spine_Slot_deform_get(self_) self_->getDeform() + + +#define spine_SlotData_index_get(self_) self_->getIndex() + + +#define spine_SlotData_name_get(self_) self_->getName() + + +#define spine_SlotData_boneData_get(self_) self_->getBoneData() + + +#define spine_SlotData_color_get(self_) self_->getColor() + + +#define spine_SlotData_darkColor_get(self_) self_->getDarkColor() + + +#define spine_SlotData_attachmentName_get(self_) self_->getAttachmentName() +#define spine_SlotData_attachmentName_set(self_, val_) self_->setAttachmentName(val_) + + +#define spine_SlotData_blendMode_get(self_) self_->getBlendMode() +#define spine_SlotData_blendMode_set(self_, val_) self_->setBlendMode(val_) + + +#define spine_TransformConstraint_data_get(self_) self_->getData() + + +#define spine_TransformConstraint_bones_get(self_) self_->getBones() + + +#define spine_TransformConstraint_target_get(self_) self_->getTarget() +#define spine_TransformConstraint_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_TransformConstraint_rotateMix_get(self_) self_->getRotateMix() +#define spine_TransformConstraint_rotateMix_set(self_, val_) self_->setRotateMix(val_) + + +#define spine_TransformConstraint_translateMix_get(self_) self_->getTranslateMix() +#define spine_TransformConstraint_translateMix_set(self_, val_) self_->setTranslateMix(val_) + + +#define spine_TransformConstraint_scaleMix_get(self_) self_->getScaleMix() +#define spine_TransformConstraint_scaleMix_set(self_, val_) self_->setScaleMix(val_) + + +#define spine_TransformConstraint_shearMix_get(self_) self_->getShearMix() +#define spine_TransformConstraint_shearMix_set(self_, val_) self_->setShearMix(val_) + + +#define spine_TransformConstraint_active_get(self_) self_->isActive() +#define spine_TransformConstraint_active_set(self_, val_) self_->setActive(val_) + + +#define spine_TransformConstraintData_bones_get(self_) self_->getBones() + + +#define spine_TransformConstraintData_target_get(self_) self_->getTarget() + + +#define spine_TransformConstraintData_rotateMix_get(self_) self_->getRotateMix() + + +#define spine_TransformConstraintData_translateMix_get(self_) self_->getTranslateMix() + + +#define spine_TransformConstraintData_scaleMix_get(self_) self_->getScaleMix() + + +#define spine_TransformConstraintData_shearMix_get(self_) self_->getShearMix() + + +#define spine_TransformConstraintData_offsetRotation_get(self_) self_->getOffsetRotation() + + +#define spine_TransformConstraintData_offsetX_get(self_) self_->getOffsetX() + + +#define spine_TransformConstraintData_offsetY_get(self_) self_->getOffsetY() + + +#define spine_TransformConstraintData_offsetScaleX_get(self_) self_->getOffsetScaleX() + + +#define spine_TransformConstraintData_offsetScaleY_get(self_) self_->getOffsetScaleY() + + +#define spine_TransformConstraintData_offsetShearY_get(self_) self_->getOffsetShearY() + + +#define spine_TransformConstraintData_relative_get(self_) self_->isRelative() + + +#define spine_TransformConstraintData_local_get(self_) self_->isLocal() + + +#define spine_Attachment_name_get(self_) self_->getName() + + +#define spine_VertexAttachment_id_get(self_) self_->getId() + + +#define spine_VertexAttachment_bones_get(self_) self_->getBones() + + +#define spine_VertexAttachment_vertices_get(self_) self_->getVertices() + + +#define spine_VertexAttachment_worldVerticesLength_get(self_) self_->getWorldVerticesLength() +#define spine_VertexAttachment_worldVerticesLength_set(self_, val_) self_->setWorldVerticesLength(val_) + + +#define spine_VertexAttachment_deformAttachment_get(self_) self_->getDeformAttachment() +#define spine_VertexAttachment_deformAttachment_set(self_, val_) self_->setDeformAttachment(val_) + + +#define spine_ClippingAttachment_endSlot_get(self_) self_->getEndSlot() +#define spine_ClippingAttachment_endSlot_set(self_, val_) self_->setEndSlot(val_) + + +#define spine_MeshAttachment_path_get(self_) self_->getPath() +#define spine_MeshAttachment_path_set(self_, val_) self_->setPath(val_) + + +#define spine_MeshAttachment_regionUVs_get(self_) self_->getRegionUVs() + + +#define spine_MeshAttachment_uvs_get(self_) self_->getUVs() + + +#define spine_MeshAttachment_triangles_get(self_) self_->getTriangles() + + +#define spine_MeshAttachment_color_get(self_) self_->getColor() + + +#define spine_MeshAttachment_width_get(self_) self_->getWidth() +#define spine_MeshAttachment_width_set(self_, val_) self_->setWidth(val_) + + +#define spine_MeshAttachment_height_get(self_) self_->getHeight() +#define spine_MeshAttachment_height_set(self_, val_) self_->setHeight(val_) + + +#define spine_MeshAttachment_hullLength_get(self_) self_->getHullLength() +#define spine_MeshAttachment_hullLength_set(self_, val_) self_->setHullLength(val_) + + +#define spine_MeshAttachment_edges_get(self_) self_->getEdges() + + +#define spine_PathAttachment_lengths_get(self_) self_->getLengths() + + +#define spine_PathAttachment_closed_get(self_) self_->isClosed() +#define spine_PathAttachment_closed_set(self_, val_) self_->setClosed(val_) + + +#define spine_PathAttachment_constantSpeed_get(self_) self_->isConstantSpeed() +#define spine_PathAttachment_constantSpeed_set(self_, val_) self_->setConstantSpeed(val_) + + +#define spine_PointAttachment_x_get(self_) self_->getX() +#define spine_PointAttachment_x_set(self_, val_) self_->setX(val_) + + +#define spine_PointAttachment_y_get(self_) self_->getY() +#define spine_PointAttachment_y_set(self_, val_) self_->setY(val_) + + +#define spine_PointAttachment_rotation_get(self_) self_->getRotation() +#define spine_PointAttachment_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_RegionAttachment_x_get(self_) self_->getX() +#define spine_RegionAttachment_x_set(self_, val_) self_->setX(val_) + + +#define spine_RegionAttachment_y_get(self_) self_->getY() +#define spine_RegionAttachment_y_set(self_, val_) self_->setY(val_) + + +#define spine_RegionAttachment_scaleX_get(self_) self_->getScaleX() +#define spine_RegionAttachment_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_RegionAttachment_scaleY_get(self_) self_->getScaleY() +#define spine_RegionAttachment_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_RegionAttachment_rotation_get(self_) self_->getRotation() +#define spine_RegionAttachment_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_RegionAttachment_width_get(self_) self_->getWidth() +#define spine_RegionAttachment_width_set(self_, val_) self_->setWidth(val_) + + +#define spine_RegionAttachment_height_get(self_) self_->getHeight() +#define spine_RegionAttachment_height_set(self_, val_) self_->setHeight(val_) + + +#define spine_RegionAttachment_color_get(self_) self_->getColor() + + +#define spine_RegionAttachment_path_get(self_) self_->getPath() +#define spine_RegionAttachment_path_set(self_, val_) self_->setPath(val_) + + +#define spine_RegionAttachment_rendererObject_get(self_) self_->getRendererObject() +#define spine_RegionAttachment_rendererObject_set(self_, val_) self_->setRendererObject(val_) + + +#define spine_RegionAttachment_offset_get(self_) self_->getOffset() + + +#define spine_RegionAttachment_uvs_get(self_) self_->getUVs() + + +#define spine_JitterVertexEffect_jitterX_get(self_) self_->getJitterX() +#define spine_JitterVertexEffect_jitterX_set(self_, val_) self_->setJitterX(val_) + + +#define spine_JitterVertexEffect_jitterY_get(self_) self_->getJitterY() +#define spine_JitterVertexEffect_jitterY_set(self_, val_) self_->setJitterY(val_) + + +#define spine_SwirlVertexEffect_centerX_get(self_) self_->getCenterX() +#define spine_SwirlVertexEffect_centerX_set(self_, val_) self_->setCenterX(val_) + + +#define spine_SwirlVertexEffect_centerY_get(self_) self_->getCenterY() +#define spine_SwirlVertexEffect_centerY_set(self_, val_) self_->setCenterY(val_) + + +#define spine_SwirlVertexEffect_radius_get(self_) self_->getRadius() +#define spine_SwirlVertexEffect_radius_set(self_, val_) self_->setRadius(val_) + + +#define spine_SwirlVertexEffect_angle_get(self_) self_->getAngle() +#define spine_SwirlVertexEffect_angle_set(self_, val_) self_->setAngle(val_) + + +#define spine_Vector2_x_get(self_) self_->getX() +#define spine_Vector2_x_set(self_, val_) self_->setX(val_) + + +#define spine_Vector2_y_get(self_) self_->getY() +#define spine_Vector2_y_set(self_, val_) self_->setY(val_) + +SWIGINTERN void spine_Timeline_apply(spine::Timeline *self,spine::Skeleton *skeleton,float lastTime,float time,ccstd::vector< spine::Event * > const &events,float alpha,spine::MixBlend blend,spine::MixDirection direction){ + spine::Vector spEvents; + for (int i = 0; i < events.size(); ++i) { + spEvents.add(events[i]); + } + self->apply(*skeleton, lastTime, time, &spEvents, alpha, blend, direction); + } +SWIGINTERN void spine_Animation_apply(spine::Animation *self,spine::Skeleton *skeleton,float lastTime,float time,bool loop,ccstd::vector< spine::Event * > const &events,float alpha,spine::MixBlend blend,spine::MixDirection direction){ + spine::Vector spEvents; + for (int i = 0; i < events.size(); ++i) { + spEvents.add(events[i]); + } + self->apply(*skeleton, lastTime, time, loop, &spEvents, alpha, blend, direction); + } +SWIGINTERN void spine_AnimationState_apply(spine::AnimationState *self,spine::Skeleton *skeleton){ + self->apply(*skeleton); + } +SWIGINTERN spine::Bone *new_spine_Bone(spine::BoneData *data,spine::Skeleton *skeleton,spine::Bone *parent){ + return new Bone(*data, *skeleton, parent); + } +SWIGINTERN void spine_Bone_updateWorldTransformWith(spine::Bone *self,float x,float y,float rotation,float scaleX,float scaleY,float shearX,float shearY){ + self->updateWorldTransform(x, y, rotation, scaleX, scaleY, shearX, shearY); + } +SWIGINTERN spine::Color &spine_Color_setFromColor(spine::Color *self,spine::Color const &other){ + return self->set(other); + } +SWIGINTERN void spine_DeformTimeline_setFrame(spine::DeformTimeline *self,int frameIndex,float time,ccstd::vector< float > const &vertices){ + spine::Vector spVertices; + for (int i = 0; i < vertices.size(); ++i) { + spVertices.add(vertices[i]); + } + self->setFrame(frameIndex, time, spVertices); + } +SWIGINTERN void spine_DrawOrderTimeline_setFrame(spine::DrawOrderTimeline *self,size_t frameIndex,float time,ccstd::vector< int > const &drawOrder){ + spine::Vector spDrawOrder; + spDrawOrder.ensureCapacity(drawOrder.size()); + for (int i = 0; i < drawOrder.size(); ++i) { + spDrawOrder.add(drawOrder[i]); + } + self->setFrame(frameIndex, time, spDrawOrder); + } +SWIGINTERN spine::Event *new_spine_Event(float time,spine::EventData *data){ + return new Event(time, *data); + } +SWIGINTERN void spine_IkConstraint_apply1(spine::IkConstraint *self,spine::Bone *bone,float targetX,float targetY,bool compress,bool stretch,bool uniform,float alpha){ + IkConstraint::apply(*bone, targetX, targetY, compress, stretch, uniform, alpha); + } +SWIGINTERN void spine_IkConstraint_apply2(spine::IkConstraint *self,spine::Bone *parent,spine::Bone *child,float targetX,float targetY,int bendDir,bool stretch,float softness,float alpha){ + IkConstraint::apply(*parent, *child, targetX, targetY, bendDir, stretch, softness, alpha); + } +SWIGINTERN spine::IkConstraint *new_spine_IkConstraint(spine::IkConstraintData *data,spine::Skeleton *skeleton){ + return new IkConstraint(*data, *skeleton); + } +SWIGINTERN spine::PathConstraint *new_spine_PathConstraint(spine::PathConstraintData *data,spine::Skeleton *skeleton){ + return new PathConstraint(*data, *skeleton); + } +SWIGINTERN float spine_PointAttachment_computeWorldRotation(spine::PointAttachment *self,spine::Bone *bone){ + return self->computeWorldRotation(*bone); + } +SWIGINTERN spine::Attachment &spine_Skeleton_getAttachmentByName(spine::Skeleton *self,std::string const &slotName,std::string const &attachmentName){ + spine::String slot(slotName.data()); + spine::String attachment(attachmentName.data()); + return *(self->getAttachment(slot, attachment)); + } +SWIGINTERN spine::Slot *new_spine_Slot(spine::SlotData *data,spine::Bone *bone){ + return new Slot(*data, *bone); + } +SWIGINTERN void spine_SkeletonBounds_update(spine::SkeletonBounds *self,spine::Skeleton *skeleton,bool updateAabb){ + self->update(*skeleton, updateAabb); + } +SWIGINTERN spine::SlotData *new_spine_SlotData(int index,ccstd::string const *name,spine::BoneData *boneData){ + spine::String spName(name->data()); + return new SlotData(index, spName, *boneData); + } +SWIGINTERN spine::SkeletonData *spine_SkeletonBinary_readSkeletonData(spine::SkeletonBinary *self,std::vector< uint8_t > const &binary){ + std::vector input; + for (int i = 0; i < binary.size(); ++i) { + input.push_back(binary[i]); + } + return self->readSkeletonData(input.data(), input.size()); + } +SWIGINTERN spine::RegionAttachment *spine_AttachmentLoader_newRegionAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name,spine::String const &path){ + return self->newRegionAttachment(*skin, name, path); + } +SWIGINTERN spine::MeshAttachment *spine_AttachmentLoader_newMeshAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name,spine::String const &path){ + return self->newMeshAttachment(*skin, name, path); + } +SWIGINTERN spine::BoundingBoxAttachment *spine_AttachmentLoader_newBoundingBoxAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newBoundingBoxAttachment(*skin, name); + } +SWIGINTERN spine::PathAttachment *spine_AttachmentLoader_newPathAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newPathAttachment(*skin, name); + } +SWIGINTERN spine::PointAttachment *spine_AttachmentLoader_newPointAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newPointAttachment(*skin, name); + } +SWIGINTERN spine::ClippingAttachment *spine_AttachmentLoader_newClippingAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newClippingAttachment(*skin, name); + } +SWIGINTERN void spine_TextureLoader_load(spine::TextureLoader *self,spine::AtlasPage *page,spine::String const &path){ + self->load(*page, path); + } +SWIGINTERN spine::TransformConstraint *new_spine_TransformConstraint(spine::TransformConstraintData *data,spine::Skeleton *skeleton){ + return new TransformConstraint(*data, *skeleton); + } +SWIGINTERN void spine_VertexEffect_begin(spine::VertexEffect *self,spine::Skeleton *skeleton){ + self->begin(*skeleton); + } +SWIGINTERN spine::SwirlVertexEffect *new_spine_SwirlVertexEffect(float radius,spine::Interpolation *interpolation){ + return new SwirlVertexEffect(radius, *interpolation); + } + + +se::Class* __jsb_spine_MathUtil_class = nullptr; +se::Object* __jsb_spine_MathUtil_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_MathUtil) + +static bool js_spine_MathUtil_signum_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sign(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_signum_static) + +static bool js_spine_MathUtil_clamp_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::clamp(arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_clamp_static) + +static bool js_spine_MathUtil_abs_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::abs(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_abs_static) + +static bool js_spine_MathUtil_sin_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sin(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_sin_static) + +static bool js_spine_MathUtil_cos_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::cos(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_cos_static) + +static bool js_spine_MathUtil_sinDeg_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sinDeg(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_sinDeg_static) + +static bool js_spine_MathUtil_cosDeg_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::cosDeg(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_cosDeg_static) + +static bool js_spine_MathUtil_atan2_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::atan2(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_atan2_static) + +static bool js_spine_MathUtil_acos_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::acos(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_acos_static) + +static bool js_spine_MathUtil_sqrt_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sqrt(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_sqrt_static) + +static bool js_spine_MathUtil_fmod_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::fmod(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_fmod_static) + +static bool js_spine_MathUtil_isNan_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)spine::MathUtil::isNan(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_isNan_static) + +static bool js_spine_MathUtil_random_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)spine::MathUtil::random(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_random_static) + +static bool js_spine_MathUtil_randomTriangular_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + float arg1 ; + float arg2 ; + float result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::randomTriangular(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_MathUtil_randomTriangular_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::randomTriangular(arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_MathUtil_randomTriangular_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_spine_MathUtil_randomTriangular_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_spine_MathUtil_randomTriangular_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_MathUtil_randomTriangular_static) + +static bool js_spine_MathUtil_pow_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::pow(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_pow_static) + +static bool js_spine_MathUtil_ipow_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint64_t arg1 ; + uint32_t arg2 ; + uint64_t result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = spine::MathUtil::ipow(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_ipow_static) + +static bool js_delete_spine_MathUtil(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_MathUtil) + +bool js_register_spine_MathUtil(se::Object* obj) { + auto* cls = se::Class::create("MathUtil", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("signum", _SE(js_spine_MathUtil_signum_static)); + cls->defineStaticFunction("clamp", _SE(js_spine_MathUtil_clamp_static)); + cls->defineStaticFunction("abs", _SE(js_spine_MathUtil_abs_static)); + cls->defineStaticFunction("sin", _SE(js_spine_MathUtil_sin_static)); + cls->defineStaticFunction("cos", _SE(js_spine_MathUtil_cos_static)); + cls->defineStaticFunction("sinDeg", _SE(js_spine_MathUtil_sinDeg_static)); + cls->defineStaticFunction("cosDeg", _SE(js_spine_MathUtil_cosDeg_static)); + cls->defineStaticFunction("atan2", _SE(js_spine_MathUtil_atan2_static)); + cls->defineStaticFunction("acos", _SE(js_spine_MathUtil_acos_static)); + cls->defineStaticFunction("sqrt", _SE(js_spine_MathUtil_sqrt_static)); + cls->defineStaticFunction("fmod", _SE(js_spine_MathUtil_fmod_static)); + cls->defineStaticFunction("isNan", _SE(js_spine_MathUtil_isNan_static)); + cls->defineStaticFunction("random", _SE(js_spine_MathUtil_random_static)); + cls->defineStaticFunction("randomTriangular", _SE(js_spine_MathUtil_randomTriangular_static)); + cls->defineStaticFunction("pow", _SE(js_spine_MathUtil_pow_static)); + cls->defineStaticFunction("ipow", _SE(js_spine_MathUtil_ipow_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_spine_MathUtil)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_MathUtil_proto = cls->getProto(); + __jsb_spine_MathUtil_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Interpolation_class = nullptr; +se::Object* __jsb_spine_Interpolation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Interpolation) + +static bool js_spine_Interpolation_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Interpolation *arg1 = (spine::Interpolation *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->apply(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Interpolation_apply) + +static bool js_spine_Interpolation_interpolate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Interpolation *arg1 = (spine::Interpolation *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->interpolate(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Interpolation_interpolate) + +static bool js_delete_spine_Interpolation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Interpolation) + +template<> +bool sevalue_to_native(const se::Value &from, spine::Interpolation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_spine_Interpolation(se::Object* obj) { + auto* cls = se::Class::create("Interpolation", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("apply", _SE(js_spine_Interpolation_apply)); + cls->defineFunction("interpolate", _SE(js_spine_Interpolation_interpolate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Interpolation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Interpolation_proto = cls->getProto(); + __jsb_spine_Interpolation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PowInterpolation_class = nullptr; +se::Object* __jsb_spine_PowInterpolation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PowInterpolation) + +static bool js_new_spine_PowInterpolation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PowInterpolation *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PowInterpolation *)new spine::PowInterpolation(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PowInterpolation, __jsb_spine_PowInterpolation_class, js_delete_spine_PowInterpolation) + +static bool js_spine_PowInterpolation_power_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PowInterpolation *arg1 = (spine::PowInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->power, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PowInterpolation_power_set) + +static bool js_spine_PowInterpolation_power_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PowInterpolation *arg1 = (spine::PowInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->power, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PowInterpolation_power_get) + +static bool js_delete_spine_PowInterpolation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PowInterpolation) + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowInterpolation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("power", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->power), ctx); + } + + + return ok; +} + + +bool js_register_spine_PowInterpolation(se::Object* obj) { + auto* cls = se::Class::create("PowInterpolation", obj, __jsb_spine_Interpolation_proto, _SE(js_new_spine_PowInterpolation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("power", _SE(js_spine_PowInterpolation_power_get), _SE(js_spine_PowInterpolation_power_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PowInterpolation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PowInterpolation_proto = cls->getProto(); + __jsb_spine_PowInterpolation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PowOutInterpolation_class = nullptr; +se::Object* __jsb_spine_PowOutInterpolation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PowOutInterpolation) + +static bool js_new_spine_PowOutInterpolation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PowOutInterpolation *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PowOutInterpolation *)new spine::PowOutInterpolation(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PowOutInterpolation, __jsb_spine_PowOutInterpolation_class, js_delete_spine_PowOutInterpolation) + +static bool js_spine_PowOutInterpolation_power_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PowOutInterpolation *arg1 = (spine::PowOutInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->power, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PowOutInterpolation_power_set) + +static bool js_spine_PowOutInterpolation_power_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PowOutInterpolation *arg1 = (spine::PowOutInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->power, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PowOutInterpolation_power_get) + +static bool js_delete_spine_PowOutInterpolation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PowOutInterpolation) + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowOutInterpolation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("power", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->power), ctx); + } + + + return ok; +} + + +bool js_register_spine_PowOutInterpolation(se::Object* obj) { + auto* cls = se::Class::create("PowOutInterpolation", obj, __jsb_spine_Interpolation_proto, _SE(js_new_spine_PowOutInterpolation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("power", _SE(js_spine_PowOutInterpolation_power_get), _SE(js_spine_PowOutInterpolation_power_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PowOutInterpolation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PowOutInterpolation_proto = cls->getProto(); + __jsb_spine_PowOutInterpolation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Timeline_class = nullptr; +se::Object* __jsb_spine_Timeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Timeline) + +static bool js_delete_spine_Timeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Timeline) + +static bool js_spine_Timeline_getPropertyId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Timeline *arg1 = (spine::Timeline *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getPropertyId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Timeline_getPropertyId) + +static bool js_spine_Timeline_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Timeline *arg1 = (spine::Timeline *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + float arg3 ; + float arg4 ; + ccstd::vector< spine::Event * > *arg5 = 0 ; + float arg6 ; + spine::MixBlend arg7 ; + spine::MixDirection arg8 ; + ccstd::vector< spine::Event * > temp5 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(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], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_Timeline_apply(arg1,arg2,arg3,arg4,(ccstd::vector< spine::Event * > const &)*arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_Timeline_apply) + +bool js_register_spine_Timeline(se::Object* obj) { + auto* cls = se::Class::create("Timeline", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getPropertyId", _SE(js_spine_Timeline_getPropertyId)); + cls->defineFunction("apply", _SE(js_spine_Timeline_apply)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Timeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Timeline_proto = cls->getProto(); + __jsb_spine_Timeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Animation_class = nullptr; +se::Object* __jsb_spine_Animation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Animation) + +static bool js_new_spine_Animation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + spine::String *arg1 = 0 ; + spine::Vector< spine::Timeline * > *arg2 = 0 ; + float arg3 ; + spine::String temp1 ; + spine::Vector< spine::Timeline * > temp2 ; + spine::Animation *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Animation *)new spine::Animation((spine::String const &)*arg1,*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Animation, __jsb_spine_Animation_class, js_delete_spine_Animation) + +static bool js_delete_spine_Animation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Animation) + +static bool js_spine_Animation_hasTimeline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Animation *arg1 = (spine::Animation *) NULL ; + int arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->hasTimeline(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Animation_hasTimeline) + +static bool js_spine_Animation_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Animation *arg1 = (spine::Animation *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Animation_name_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_spine_Animation_name_get) + +static bool js_spine_Animation_timelines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Animation *arg1 = (spine::Animation *) NULL ; + spine::Vector< spine::Timeline * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Timeline * > *) &spine_Animation_timelines_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_spine_Animation_timelines_get) + +static bool js_spine_Animation_duration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Animation *arg1 = (spine::Animation *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Animation_duration_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Animation_duration_set) + +static bool js_spine_Animation_duration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Animation *arg1 = (spine::Animation *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Animation_duration_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Animation_duration_get) + +static bool js_spine_Animation_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Animation *arg1 = (spine::Animation *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + float arg3 ; + float arg4 ; + bool arg5 ; + ccstd::vector< spine::Event * > *arg6 = 0 ; + float arg7 ; + spine::MixBlend arg8 ; + spine::MixDirection arg9 ; + ccstd::vector< spine::Event * > temp6 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_Animation_apply(arg1,arg2,arg3,arg4,arg5,(ccstd::vector< spine::Event * > const &)*arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_spine_Animation_apply) + +bool js_register_spine_Animation(se::Object* obj) { + auto* cls = se::Class::create("Animation", obj, nullptr, _SE(js_new_spine_Animation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_Animation_name_get), nullptr); + cls->defineProperty("timelines", _SE(js_spine_Animation_timelines_get), nullptr); + cls->defineProperty("duration", _SE(js_spine_Animation_duration_get), _SE(js_spine_Animation_duration_set)); + + cls->defineFunction("hasTimeline", _SE(js_spine_Animation_hasTimeline)); + cls->defineFunction("apply", _SE(js_spine_Animation_apply)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Animation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Animation_proto = cls->getProto(); + __jsb_spine_Animation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AnimationStateListenerObject_class = nullptr; +se::Object* __jsb_spine_AnimationStateListenerObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AnimationStateListenerObject) + +static bool js_delete_spine_AnimationStateListenerObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AnimationStateListenerObject) + +static bool js_spine_AnimationStateListenerObject_callback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationStateListenerObject *arg1 = (spine::AnimationStateListenerObject *) NULL ; + spine::AnimationState *arg2 = (spine::AnimationState *) NULL ; + spine::EventType arg3 ; + spine::TrackEntry *arg4 = (spine::TrackEntry *) NULL ; + spine::Event *arg5 = (spine::Event *) NULL ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->callback(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationStateListenerObject_callback) + +bool js_register_spine_AnimationStateListenerObject(se::Object* obj) { + auto* cls = se::Class::create("AnimationStateListenerObject", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("callback", _SE(js_spine_AnimationStateListenerObject_callback)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AnimationStateListenerObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AnimationStateListenerObject_proto = cls->getProto(); + __jsb_spine_AnimationStateListenerObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TrackEntry_class = nullptr; +se::Object* __jsb_spine_TrackEntry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TrackEntry) + +static bool js_new_spine_TrackEntry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::TrackEntry *result; + result = (spine::TrackEntry *)new spine::TrackEntry(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TrackEntry, __jsb_spine_TrackEntry_class, js_delete_spine_TrackEntry) + +static bool js_delete_spine_TrackEntry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TrackEntry) + +static bool js_spine_TrackEntry_getAnimationTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getAnimationTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_TrackEntry_getAnimationTime) + +static bool js_spine_TrackEntry_isComplete(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isComplete(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_TrackEntry_isComplete) + +static bool js_spine_TrackEntry_resetRotationDirections(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetRotationDirections(); + + + return true; +} +SE_BIND_FUNC(js_spine_TrackEntry_resetRotationDirections) + +static bool js_spine_TrackEntry_animation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::Animation *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Animation *)spine_TrackEntry_animation_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_spine_TrackEntry_animation_get) + +static bool js_spine_TrackEntry_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)spine_TrackEntry_next_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_spine_TrackEntry_next_get) + +static bool js_spine_TrackEntry_mixingFrom_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)spine_TrackEntry_mixingFrom_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_spine_TrackEntry_mixingFrom_get) + +static bool js_spine_TrackEntry_mixingTo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)spine_TrackEntry_mixingTo_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_spine_TrackEntry_mixingTo_get) + +static bool js_spine_TrackEntry_trackIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_TrackEntry_trackIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_trackIndex_get) + +static bool js_spine_TrackEntry_loop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_loop_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_loop_set) + +static bool js_spine_TrackEntry_loop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TrackEntry_loop_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_loop_get) + +static bool js_spine_TrackEntry_holdPrevious_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_holdPrevious_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_holdPrevious_set) + +static bool js_spine_TrackEntry_holdPrevious_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TrackEntry_holdPrevious_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_holdPrevious_get) + +static bool js_spine_TrackEntry_eventThreshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_eventThreshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_eventThreshold_set) + +static bool js_spine_TrackEntry_eventThreshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_eventThreshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_eventThreshold_get) + +static bool js_spine_TrackEntry_attachmentThreshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_attachmentThreshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_attachmentThreshold_set) + +static bool js_spine_TrackEntry_attachmentThreshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_attachmentThreshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_attachmentThreshold_get) + +static bool js_spine_TrackEntry_drawOrderThreshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_drawOrderThreshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_drawOrderThreshold_set) + +static bool js_spine_TrackEntry_drawOrderThreshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_drawOrderThreshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_drawOrderThreshold_get) + +static bool js_spine_TrackEntry_animationStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_animationStart_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_animationStart_set) + +static bool js_spine_TrackEntry_animationStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_animationStart_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_animationStart_get) + +static bool js_spine_TrackEntry_animationEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_animationEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_animationEnd_set) + +static bool js_spine_TrackEntry_animationEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_animationEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_animationEnd_get) + +static bool js_spine_TrackEntry_animationLast_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_animationLast_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_animationLast_set) + +static bool js_spine_TrackEntry_animationLast_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_animationLast_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_animationLast_get) + +static bool js_spine_TrackEntry_delay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_delay_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_delay_set) + +static bool js_spine_TrackEntry_delay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_delay_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_delay_get) + +static bool js_spine_TrackEntry_trackTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_trackTime_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_trackTime_set) + +static bool js_spine_TrackEntry_trackTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_trackTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_trackTime_get) + +static bool js_spine_TrackEntry_trackEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_trackEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_trackEnd_set) + +static bool js_spine_TrackEntry_trackEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_trackEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_trackEnd_get) + +static bool js_spine_TrackEntry_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_timeScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_timeScale_set) + +static bool js_spine_TrackEntry_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_timeScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_timeScale_get) + +static bool js_spine_TrackEntry_alpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_alpha_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_alpha_set) + +static bool js_spine_TrackEntry_alpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_alpha_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_alpha_get) + +static bool js_spine_TrackEntry_mixTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_mixTime_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_mixTime_set) + +static bool js_spine_TrackEntry_mixTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_mixTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_mixTime_get) + +static bool js_spine_TrackEntry_mixDuration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_mixDuration_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_mixDuration_set) + +static bool js_spine_TrackEntry_mixDuration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_mixDuration_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_mixDuration_get) + +static bool js_spine_TrackEntry_mixBlend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::MixBlend arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_TrackEntry_mixBlend_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_mixBlend_set) + +static bool js_spine_TrackEntry_mixBlend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::MixBlend result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::MixBlend)spine_TrackEntry_mixBlend_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_spine_TrackEntry_mixBlend_get) + +bool js_register_spine_TrackEntry(se::Object* obj) { + auto* cls = se::Class::create("TrackEntry", obj, nullptr, _SE(js_new_spine_TrackEntry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("animation", _SE(js_spine_TrackEntry_animation_get), nullptr); + cls->defineProperty("next", _SE(js_spine_TrackEntry_next_get), nullptr); + cls->defineProperty("mixingFrom", _SE(js_spine_TrackEntry_mixingFrom_get), nullptr); + cls->defineProperty("mixingTo", _SE(js_spine_TrackEntry_mixingTo_get), nullptr); + cls->defineProperty("trackIndex", _SE(js_spine_TrackEntry_trackIndex_get), nullptr); + cls->defineProperty("loop", _SE(js_spine_TrackEntry_loop_get), _SE(js_spine_TrackEntry_loop_set)); + cls->defineProperty("holdPrevious", _SE(js_spine_TrackEntry_holdPrevious_get), _SE(js_spine_TrackEntry_holdPrevious_set)); + cls->defineProperty("eventThreshold", _SE(js_spine_TrackEntry_eventThreshold_get), _SE(js_spine_TrackEntry_eventThreshold_set)); + cls->defineProperty("attachmentThreshold", _SE(js_spine_TrackEntry_attachmentThreshold_get), _SE(js_spine_TrackEntry_attachmentThreshold_set)); + cls->defineProperty("drawOrderThreshold", _SE(js_spine_TrackEntry_drawOrderThreshold_get), _SE(js_spine_TrackEntry_drawOrderThreshold_set)); + cls->defineProperty("animationStart", _SE(js_spine_TrackEntry_animationStart_get), _SE(js_spine_TrackEntry_animationStart_set)); + cls->defineProperty("animationEnd", _SE(js_spine_TrackEntry_animationEnd_get), _SE(js_spine_TrackEntry_animationEnd_set)); + cls->defineProperty("animationLast", _SE(js_spine_TrackEntry_animationLast_get), _SE(js_spine_TrackEntry_animationLast_set)); + cls->defineProperty("delay", _SE(js_spine_TrackEntry_delay_get), _SE(js_spine_TrackEntry_delay_set)); + cls->defineProperty("trackTime", _SE(js_spine_TrackEntry_trackTime_get), _SE(js_spine_TrackEntry_trackTime_set)); + cls->defineProperty("trackEnd", _SE(js_spine_TrackEntry_trackEnd_get), _SE(js_spine_TrackEntry_trackEnd_set)); + cls->defineProperty("timeScale", _SE(js_spine_TrackEntry_timeScale_get), _SE(js_spine_TrackEntry_timeScale_set)); + cls->defineProperty("alpha", _SE(js_spine_TrackEntry_alpha_get), _SE(js_spine_TrackEntry_alpha_set)); + cls->defineProperty("mixTime", _SE(js_spine_TrackEntry_mixTime_get), _SE(js_spine_TrackEntry_mixTime_set)); + cls->defineProperty("mixDuration", _SE(js_spine_TrackEntry_mixDuration_get), _SE(js_spine_TrackEntry_mixDuration_set)); + cls->defineProperty("mixBlend", _SE(js_spine_TrackEntry_mixBlend_get), _SE(js_spine_TrackEntry_mixBlend_set)); + + cls->defineFunction("getAnimationTime", _SE(js_spine_TrackEntry_getAnimationTime)); + cls->defineFunction("isComplete", _SE(js_spine_TrackEntry_isComplete)); + cls->defineFunction("resetRotationDirections", _SE(js_spine_TrackEntry_resetRotationDirections)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TrackEntry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TrackEntry_proto = cls->getProto(); + __jsb_spine_TrackEntry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventQueueEntry_class = nullptr; +se::Object* __jsb_spine_EventQueueEntry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventQueueEntry) + +static bool js_spine_EventQueueEntry__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventQueueEntry__type_set) + +static bool js_spine_EventQueueEntry__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventQueueEntry__type_get) + +static bool js_spine_EventQueueEntry__entry_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_entry, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventQueueEntry__entry_set) + +static bool js_spine_EventQueueEntry__entry_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_entry, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_entry, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventQueueEntry__entry_get) + +static bool js_spine_EventQueueEntry__event_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_event, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventQueueEntry__event_set) + +static bool js_spine_EventQueueEntry__event_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_event, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_event, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventQueueEntry__event_get) + +static bool js_new_spine_EventQueueEntry__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::EventType arg1 ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + spine::Event *arg3 = (spine::Event *) NULL ; + spine::EventQueueEntry *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::EventQueueEntry *)new spine::EventQueueEntry(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_EventQueueEntry__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::EventType arg1 ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + spine::EventQueueEntry *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::EventQueueEntry *)new spine::EventQueueEntry(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_EventQueueEntry(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_spine_EventQueueEntry__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_spine_EventQueueEntry__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of EventQueueEntry"); + return false; +} +SE_BIND_CTOR(js_new_spine_EventQueueEntry, __jsb_spine_EventQueueEntry_class, js_delete_spine_EventQueueEntry) + +static bool js_delete_spine_EventQueueEntry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_EventQueueEntry) + +bool js_register_spine_EventQueueEntry(se::Object* obj) { + auto* cls = se::Class::create("EventQueueEntry", obj, nullptr, _SE(js_new_spine_EventQueueEntry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_type", _SE(js_spine_EventQueueEntry__type_get), _SE(js_spine_EventQueueEntry__type_set)); + cls->defineProperty("_entry", _SE(js_spine_EventQueueEntry__entry_get), _SE(js_spine_EventQueueEntry__entry_set)); + cls->defineProperty("_event", _SE(js_spine_EventQueueEntry__event_get), _SE(js_spine_EventQueueEntry__event_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_EventQueueEntry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventQueueEntry_proto = cls->getProto(); + __jsb_spine_EventQueueEntry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventQueue_class = nullptr; +se::Object* __jsb_spine_EventQueue_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventQueue) + +bool js_register_spine_EventQueue(se::Object* obj) { + auto* cls = se::Class::create("EventQueue", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventQueue_proto = cls->getProto(); + __jsb_spine_EventQueue_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AnimationState_class = nullptr; +se::Object* __jsb_spine_AnimationState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AnimationState) + +static bool js_new_spine_AnimationState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::AnimationState *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::AnimationState *)new spine::AnimationState(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AnimationState, __jsb_spine_AnimationState_class, js_delete_spine_AnimationState) + +static bool js_delete_spine_AnimationState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AnimationState) + +static bool js_spine_AnimationState_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_update) + +static bool js_spine_AnimationState_clearTracks(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearTracks(); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_clearTracks) + +static bool js_spine_AnimationState_clearTrack(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->clearTrack(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_clearTrack) + +static bool js_spine_AnimationState_setAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + bool arg4 ; + spine::String temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->setAnimation(arg2,(spine::String const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_setAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + bool arg4 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->setAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_setAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_spine_AnimationState_setAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_spine_AnimationState_setAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_AnimationState_setAnimation) + +static bool js_spine_AnimationState_addAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + bool arg4 ; + float arg5 ; + spine::String temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,(spine::String const &)*arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_addAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + bool arg4 ; + float arg5 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_addAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_AnimationState_addAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_spine_AnimationState_addAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_AnimationState_addAnimation) + +static bool js_spine_AnimationState_setEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + float arg3 ; + spine::TrackEntry *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(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 = (spine::TrackEntry *)(arg1)->setEmptyAnimation(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_spine_AnimationState_setEmptyAnimation) + +static bool js_spine_AnimationState_addEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + float arg3 ; + float arg4 ; + spine::TrackEntry *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addEmptyAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_addEmptyAnimation) + +static bool js_spine_AnimationState_setEmptyAnimations(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEmptyAnimations(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_setEmptyAnimations) + +static bool js_spine_AnimationState_getCurrent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::TrackEntry *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (spine::TrackEntry *)(arg1)->getCurrent(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_spine_AnimationState_getCurrent) + +static bool js_spine_AnimationState_disableQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->disableQueue(); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_disableQueue) + +static bool js_spine_AnimationState_enableQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->enableQueue(); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_enableQueue) + +static bool js_spine_AnimationState_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + spine::AnimationStateData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::AnimationStateData *)spine_AnimationState_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AnimationState_data_get) + +static bool js_spine_AnimationState_tracks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + spine::Vector< spine::TrackEntry * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::TrackEntry * > *) &spine_AnimationState_tracks_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_spine_AnimationState_tracks_get) + +static bool js_spine_AnimationState_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_AnimationState_timeScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_AnimationState_timeScale_set) + +static bool js_spine_AnimationState_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_AnimationState_timeScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AnimationState_timeScale_get) + +static bool js_spine_AnimationState_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_AnimationState_apply(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_apply) + +bool js_register_spine_AnimationState(se::Object* obj) { + auto* cls = se::Class::create("AnimationState", obj, nullptr, _SE(js_new_spine_AnimationState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_AnimationState_data_get), nullptr); + cls->defineProperty("tracks", _SE(js_spine_AnimationState_tracks_get), nullptr); + cls->defineProperty("timeScale", _SE(js_spine_AnimationState_timeScale_get), _SE(js_spine_AnimationState_timeScale_set)); + + cls->defineFunction("update", _SE(js_spine_AnimationState_update)); + cls->defineFunction("clearTracks", _SE(js_spine_AnimationState_clearTracks)); + cls->defineFunction("clearTrack", _SE(js_spine_AnimationState_clearTrack)); + cls->defineFunction("setAnimation", _SE(js_spine_AnimationState_setAnimation)); + cls->defineFunction("addAnimation", _SE(js_spine_AnimationState_addAnimation)); + cls->defineFunction("setEmptyAnimation", _SE(js_spine_AnimationState_setEmptyAnimation)); + cls->defineFunction("addEmptyAnimation", _SE(js_spine_AnimationState_addEmptyAnimation)); + cls->defineFunction("setEmptyAnimations", _SE(js_spine_AnimationState_setEmptyAnimations)); + cls->defineFunction("getCurrent", _SE(js_spine_AnimationState_getCurrent)); + cls->defineFunction("disableQueue", _SE(js_spine_AnimationState_disableQueue)); + cls->defineFunction("enableQueue", _SE(js_spine_AnimationState_enableQueue)); + cls->defineFunction("apply", _SE(js_spine_AnimationState_apply)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AnimationState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AnimationState_proto = cls->getProto(); + __jsb_spine_AnimationState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AnimationStateData_class = nullptr; +se::Object* __jsb_spine_AnimationStateData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AnimationStateData) + +static bool js_new_spine_AnimationStateData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::AnimationStateData *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::AnimationStateData *)new spine::AnimationStateData(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AnimationStateData, __jsb_spine_AnimationStateData_class, js_delete_spine_AnimationStateData) + +static bool js_spine_AnimationStateData_setMixWith__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::String *arg2 = 0 ; + spine::String *arg3 = 0 ; + float arg4 ; + spine::String temp2 ; + spine::String temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMix((spine::String const &)*arg2,(spine::String const &)*arg3,arg4); + + + return true; +} + +static bool js_spine_AnimationStateData_setMixWith__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::Animation *arg2 = (spine::Animation *) NULL ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setMix(arg2,arg3,arg4); + + + return true; +} + +static bool js_spine_AnimationStateData_setMixWith(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_spine_AnimationStateData_setMixWith__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_spine_AnimationStateData_setMixWith__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_AnimationStateData_setMixWith) + +static bool js_spine_AnimationStateData_getMix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::Animation *arg2 = (spine::Animation *) NULL ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + float result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (float)(arg1)->getMix(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationStateData_getMix) + +static bool js_spine_AnimationStateData_skeletonData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::SkeletonData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SkeletonData *)spine_AnimationStateData_skeletonData_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_spine_AnimationStateData_skeletonData_get) + +static bool js_spine_AnimationStateData_defaultMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_AnimationStateData_defaultMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_AnimationStateData_defaultMix_set) + +static bool js_spine_AnimationStateData_defaultMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_AnimationStateData_defaultMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AnimationStateData_defaultMix_get) + +static bool js_delete_spine_AnimationStateData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AnimationStateData) + +bool js_register_spine_AnimationStateData(se::Object* obj) { + auto* cls = se::Class::create("AnimationStateData", obj, nullptr, _SE(js_new_spine_AnimationStateData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("skeletonData", _SE(js_spine_AnimationStateData_skeletonData_get), nullptr); + cls->defineProperty("defaultMix", _SE(js_spine_AnimationStateData_defaultMix_get), _SE(js_spine_AnimationStateData_defaultMix_set)); + + cls->defineFunction("setMixWith", _SE(js_spine_AnimationStateData_setMixWith)); + cls->defineFunction("getMix", _SE(js_spine_AnimationStateData_getMix)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AnimationStateData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AnimationStateData_proto = cls->getProto(); + __jsb_spine_AnimationStateData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Attachment_class = nullptr; +se::Object* __jsb_spine_Attachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Attachment) + +static bool js_delete_spine_Attachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Attachment) + +static bool js_spine_Attachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + result = (spine::Attachment *)(arg1)->copy(); + + 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_spine_Attachment_copy) + +static bool js_spine_Attachment_getRefCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((spine::Attachment const *)arg1)->getRefCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Attachment_getRefCount) + +static bool js_spine_Attachment_reference(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reference(); + + + return true; +} +SE_BIND_FUNC(js_spine_Attachment_reference) + +static bool js_spine_Attachment_dereference(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dereference(); + + + return true; +} +SE_BIND_FUNC(js_spine_Attachment_dereference) + +static bool js_spine_Attachment_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Attachment_name_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_spine_Attachment_name_get) + +bool js_register_spine_Attachment(se::Object* obj) { + auto* cls = se::Class::create("Attachment", 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_spine_Attachment_name_get), nullptr); + + cls->defineFunction("copy", _SE(js_spine_Attachment_copy)); + cls->defineFunction("getRefCount", _SE(js_spine_Attachment_getRefCount)); + cls->defineFunction("reference", _SE(js_spine_Attachment_reference)); + cls->defineFunction("dereference", _SE(js_spine_Attachment_dereference)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Attachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Attachment_proto = cls->getProto(); + __jsb_spine_Attachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AttachmentTimeline_class = nullptr; +se::Object* __jsb_spine_AttachmentTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AttachmentTimeline) + +static bool js_new_spine_AttachmentTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::AttachmentTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::AttachmentTimeline *)new spine::AttachmentTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AttachmentTimeline, __jsb_spine_AttachmentTimeline_class, js_delete_spine_AttachmentTimeline) + +static bool js_spine_AttachmentTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + int arg2 ; + float arg3 ; + spine::String *arg4 = 0 ; + spine::String temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->setFrame(arg2,arg3,(spine::String const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentTimeline_setFrame) + +static bool js_spine_AttachmentTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentTimeline_getFrameCount) + +static bool js_spine_AttachmentTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + size_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_AttachmentTimeline_slotIndex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_spine_AttachmentTimeline_slotIndex_set) + +static bool js_spine_AttachmentTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + size_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_AttachmentTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AttachmentTimeline_slotIndex_get) + +static bool js_spine_AttachmentTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_AttachmentTimeline_frames_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_spine_AttachmentTimeline_frames_get) + +static bool js_spine_AttachmentTimeline_attachmentNames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + spine::Vector< spine::String > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::String > *) &spine_AttachmentTimeline_attachmentNames_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_spine_AttachmentTimeline_attachmentNames_get) + +static bool js_delete_spine_AttachmentTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AttachmentTimeline) + +bool js_register_spine_AttachmentTimeline(se::Object* obj) { + auto* cls = se::Class::create("AttachmentTimeline", obj, __jsb_spine_Timeline_proto, _SE(js_new_spine_AttachmentTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_AttachmentTimeline_slotIndex_get), _SE(js_spine_AttachmentTimeline_slotIndex_set)); + cls->defineProperty("frames", _SE(js_spine_AttachmentTimeline_frames_get), nullptr); + cls->defineProperty("attachmentNames", _SE(js_spine_AttachmentTimeline_attachmentNames_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_AttachmentTimeline_setFrame)); + cls->defineFunction("getFrameCount", _SE(js_spine_AttachmentTimeline_getFrameCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AttachmentTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AttachmentTimeline_proto = cls->getProto(); + __jsb_spine_AttachmentTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_VertexAttachment_class = nullptr; +se::Object* __jsb_spine_VertexAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_VertexAttachment) + +static bool js_delete_spine_VertexAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_VertexAttachment) + +static bool js_spine_VertexAttachment_copyTo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::VertexAttachment *arg2 = (spine::VertexAttachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->copyTo(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_VertexAttachment_copyTo) + +static bool js_spine_VertexAttachment_id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_VertexAttachment_id_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_VertexAttachment_id_get) + +static bool js_spine_VertexAttachment_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::Vector< size_t > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< size_t > *) &spine_VertexAttachment_bones_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_spine_VertexAttachment_bones_get) + +static bool js_spine_VertexAttachment_vertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_VertexAttachment_vertices_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_spine_VertexAttachment_vertices_get) + +static bool js_spine_VertexAttachment_worldVerticesLength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + size_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_VertexAttachment_worldVerticesLength_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_spine_VertexAttachment_worldVerticesLength_set) + +static bool js_spine_VertexAttachment_worldVerticesLength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + size_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_VertexAttachment_worldVerticesLength_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_VertexAttachment_worldVerticesLength_get) + +static bool js_spine_VertexAttachment_deformAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::VertexAttachment *arg2 = (spine::VertexAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_VertexAttachment_deformAttachment_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_VertexAttachment_deformAttachment_set) + +static bool js_spine_VertexAttachment_deformAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::VertexAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::VertexAttachment *)spine_VertexAttachment_deformAttachment_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_spine_VertexAttachment_deformAttachment_get) + +bool js_register_spine_VertexAttachment(se::Object* obj) { + auto* cls = se::Class::create("VertexAttachment", obj, __jsb_spine_Attachment_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("id", _SE(js_spine_VertexAttachment_id_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_VertexAttachment_bones_get), nullptr); + cls->defineProperty("vertices", _SE(js_spine_VertexAttachment_vertices_get), nullptr); + cls->defineProperty("worldVerticesLength", _SE(js_spine_VertexAttachment_worldVerticesLength_get), _SE(js_spine_VertexAttachment_worldVerticesLength_set)); + cls->defineProperty("deformAttachment", _SE(js_spine_VertexAttachment_deformAttachment_get), _SE(js_spine_VertexAttachment_deformAttachment_set)); + + cls->defineFunction("copyTo", _SE(js_spine_VertexAttachment_copyTo)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_VertexAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_VertexAttachment_proto = cls->getProto(); + __jsb_spine_VertexAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_BoundingBoxAttachment_class = nullptr; +se::Object* __jsb_spine_BoundingBoxAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_BoundingBoxAttachment) + +static bool js_new_spine_BoundingBoxAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::BoundingBoxAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::BoundingBoxAttachment *)new spine::BoundingBoxAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_BoundingBoxAttachment, __jsb_spine_BoundingBoxAttachment_class, js_delete_spine_BoundingBoxAttachment) + +static bool js_delete_spine_BoundingBoxAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_BoundingBoxAttachment) + +bool js_register_spine_BoundingBoxAttachment(se::Object* obj) { + auto* cls = se::Class::create("BoundingBoxAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_BoundingBoxAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_BoundingBoxAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_BoundingBoxAttachment_proto = cls->getProto(); + __jsb_spine_BoundingBoxAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Bone_class = nullptr; +se::Object* __jsb_spine_Bone_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Bone) + +static bool js_spine_Bone_setYDown_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine::Bone::setYDown(arg1); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_setYDown_static) + +static bool js_spine_Bone_isYDown_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)spine::Bone::isYDown(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_isYDown_static) + +static bool js_spine_Bone_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_update) + +static bool js_spine_Bone_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_updateWorldTransform) + +static bool js_spine_Bone_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_setToSetupPose) + +static bool js_spine_Bone_worldToLocalRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->worldToLocalRotation(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_worldToLocalRotation) + +static bool js_spine_Bone_localToWorldRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->localToWorldRotation(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_localToWorldRotation) + +static bool js_spine_Bone_rotateWorld(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->rotateWorld(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_rotateWorld) + +static bool js_spine_Bone_getWorldToLocalRotationX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldToLocalRotationX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldToLocalRotationX) + +static bool js_spine_Bone_getWorldToLocalRotationY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldToLocalRotationY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldToLocalRotationY) + +static bool js_spine_Bone_getWorldRotationX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldRotationX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldRotationX) + +static bool js_spine_Bone_getWorldRotationY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldRotationY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldRotationY) + +static bool js_spine_Bone_getWorldScaleX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldScaleX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldScaleX) + +static bool js_spine_Bone_getWorldScaleY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldScaleY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldScaleY) + +static bool js_spine_Bone_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *) &spine_Bone_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_data_get) + +static bool js_spine_Bone_skeleton_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::Skeleton *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *) &spine_Bone_skeleton_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_spine_Bone_skeleton_get) + +static bool js_spine_Bone_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)spine_Bone_parent_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_spine_Bone_parent_get) + +static bool js_spine_Bone_children_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_Bone_children_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_spine_Bone_children_get) + +static bool js_spine_Bone_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_x_set) + +static bool js_spine_Bone_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_x_get) + +static bool js_spine_Bone_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_y_set) + +static bool js_spine_Bone_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_y_get) + +static bool js_spine_Bone_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_rotation_set) + +static bool js_spine_Bone_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_rotation_get) + +static bool js_spine_Bone_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_scaleX_set) + +static bool js_spine_Bone_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_scaleX_get) + +static bool js_spine_Bone_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_scaleY_set) + +static bool js_spine_Bone_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_scaleY_get) + +static bool js_spine_Bone_shearX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_shearX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_shearX_set) + +static bool js_spine_Bone_shearX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_shearX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_shearX_get) + +static bool js_spine_Bone_shearY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_shearY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_shearY_set) + +static bool js_spine_Bone_shearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_shearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_shearY_get) + +static bool js_spine_Bone_ax_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ax_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ax_set) + +static bool js_spine_Bone_ax_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ax_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ax_get) + +static bool js_spine_Bone_ay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ay_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ay_set) + +static bool js_spine_Bone_ay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ay_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ay_get) + +static bool js_spine_Bone_arotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_arotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_arotation_set) + +static bool js_spine_Bone_arotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_arotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_arotation_get) + +static bool js_spine_Bone_ascaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ascaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ascaleX_set) + +static bool js_spine_Bone_ascaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ascaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ascaleX_get) + +static bool js_spine_Bone_ascaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ascaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ascaleY_set) + +static bool js_spine_Bone_ascaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ascaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ascaleY_get) + +static bool js_spine_Bone_ashearX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ashearX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ashearX_set) + +static bool js_spine_Bone_ashearX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ashearX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ashearX_get) + +static bool js_spine_Bone_ashearY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ashearY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ashearY_set) + +static bool js_spine_Bone_ashearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ashearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ashearY_get) + +static bool js_spine_Bone_appliedValid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_appliedValid_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_appliedValid_set) + +static bool js_spine_Bone_appliedValid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_Bone_appliedValid_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_appliedValid_get) + +static bool js_spine_Bone_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_a_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_a_set) + +static bool js_spine_Bone_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_a_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_a_get) + +static bool js_spine_Bone_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_b_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_b_set) + +static bool js_spine_Bone_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_b_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_b_get) + +static bool js_spine_Bone_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_c_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_c_set) + +static bool js_spine_Bone_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_c_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_c_get) + +static bool js_spine_Bone_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_d_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_d_set) + +static bool js_spine_Bone_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_d_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_d_get) + +static bool js_spine_Bone_worldX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_worldX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_worldX_set) + +static bool js_spine_Bone_worldX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_worldX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_worldX_get) + +static bool js_spine_Bone_worldY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_worldY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_worldY_set) + +static bool js_spine_Bone_worldY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_worldY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_worldY_get) + +static bool js_spine_Bone_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_active_set) + +static bool js_spine_Bone_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_Bone_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_active_get) + +static bool js_new_spine_Bone(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::Bone *arg3 = (spine::Bone *) NULL ; + spine::Bone *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Bone *)new_spine_Bone(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Bone, __jsb_spine_Bone_class, js_delete_spine_Bone) + +static bool js_spine_Bone_updateWorldTransformWith(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_updateWorldTransformWith(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_updateWorldTransformWith) + +static bool js_delete_spine_Bone(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Bone) + +bool js_register_spine_Bone(se::Object* obj) { + auto* cls = se::Class::create("Bone", obj, nullptr, _SE(js_new_spine_Bone)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Bone_data_get), nullptr); + cls->defineProperty("skeleton", _SE(js_spine_Bone_skeleton_get), nullptr); + cls->defineProperty("parent", _SE(js_spine_Bone_parent_get), nullptr); + cls->defineProperty("children", _SE(js_spine_Bone_children_get), nullptr); + cls->defineProperty("x", _SE(js_spine_Bone_x_get), _SE(js_spine_Bone_x_set)); + cls->defineProperty("y", _SE(js_spine_Bone_y_get), _SE(js_spine_Bone_y_set)); + cls->defineProperty("rotation", _SE(js_spine_Bone_rotation_get), _SE(js_spine_Bone_rotation_set)); + cls->defineProperty("scaleX", _SE(js_spine_Bone_scaleX_get), _SE(js_spine_Bone_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_Bone_scaleY_get), _SE(js_spine_Bone_scaleY_set)); + cls->defineProperty("shearX", _SE(js_spine_Bone_shearX_get), _SE(js_spine_Bone_shearX_set)); + cls->defineProperty("shearY", _SE(js_spine_Bone_shearY_get), _SE(js_spine_Bone_shearY_set)); + cls->defineProperty("ax", _SE(js_spine_Bone_ax_get), _SE(js_spine_Bone_ax_set)); + cls->defineProperty("ay", _SE(js_spine_Bone_ay_get), _SE(js_spine_Bone_ay_set)); + cls->defineProperty("arotation", _SE(js_spine_Bone_arotation_get), _SE(js_spine_Bone_arotation_set)); + cls->defineProperty("ascaleX", _SE(js_spine_Bone_ascaleX_get), _SE(js_spine_Bone_ascaleX_set)); + cls->defineProperty("ascaleY", _SE(js_spine_Bone_ascaleY_get), _SE(js_spine_Bone_ascaleY_set)); + cls->defineProperty("ashearX", _SE(js_spine_Bone_ashearX_get), _SE(js_spine_Bone_ashearX_set)); + cls->defineProperty("ashearY", _SE(js_spine_Bone_ashearY_get), _SE(js_spine_Bone_ashearY_set)); + cls->defineProperty("appliedValid", _SE(js_spine_Bone_appliedValid_get), _SE(js_spine_Bone_appliedValid_set)); + cls->defineProperty("a", _SE(js_spine_Bone_a_get), _SE(js_spine_Bone_a_set)); + cls->defineProperty("b", _SE(js_spine_Bone_b_get), _SE(js_spine_Bone_b_set)); + cls->defineProperty("c", _SE(js_spine_Bone_c_get), _SE(js_spine_Bone_c_set)); + cls->defineProperty("d", _SE(js_spine_Bone_d_get), _SE(js_spine_Bone_d_set)); + cls->defineProperty("worldX", _SE(js_spine_Bone_worldX_get), _SE(js_spine_Bone_worldX_set)); + cls->defineProperty("worldY", _SE(js_spine_Bone_worldY_get), _SE(js_spine_Bone_worldY_set)); + cls->defineProperty("active", _SE(js_spine_Bone_active_get), _SE(js_spine_Bone_active_set)); + + cls->defineFunction("update", _SE(js_spine_Bone_update)); + cls->defineFunction("updateWorldTransform", _SE(js_spine_Bone_updateWorldTransform)); + cls->defineFunction("setToSetupPose", _SE(js_spine_Bone_setToSetupPose)); + cls->defineFunction("worldToLocalRotation", _SE(js_spine_Bone_worldToLocalRotation)); + cls->defineFunction("localToWorldRotation", _SE(js_spine_Bone_localToWorldRotation)); + cls->defineFunction("rotateWorld", _SE(js_spine_Bone_rotateWorld)); + cls->defineFunction("getWorldToLocalRotationX", _SE(js_spine_Bone_getWorldToLocalRotationX)); + cls->defineFunction("getWorldToLocalRotationY", _SE(js_spine_Bone_getWorldToLocalRotationY)); + cls->defineFunction("getWorldRotationX", _SE(js_spine_Bone_getWorldRotationX)); + cls->defineFunction("getWorldRotationY", _SE(js_spine_Bone_getWorldRotationY)); + cls->defineFunction("getWorldScaleX", _SE(js_spine_Bone_getWorldScaleX)); + cls->defineFunction("getWorldScaleY", _SE(js_spine_Bone_getWorldScaleY)); + cls->defineFunction("updateWorldTransformWith", _SE(js_spine_Bone_updateWorldTransformWith)); + + + cls->defineStaticFunction("setYDown", _SE(js_spine_Bone_setYDown_static)); + cls->defineStaticFunction("isYDown", _SE(js_spine_Bone_isYDown_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Bone)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Bone_proto = cls->getProto(); + __jsb_spine_Bone_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_BoneData_class = nullptr; +se::Object* __jsb_spine_BoneData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_BoneData) + +static bool js_new_spine_BoneData__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + int arg1 ; + spine::String *arg2 = 0 ; + spine::BoneData *arg3 = (spine::BoneData *) NULL ; + spine::String temp2 ; + spine::BoneData *result; + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::BoneData *)new spine::BoneData(arg1,(spine::String const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_BoneData__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + int arg1 ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::BoneData *result; + + 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 = (spine::BoneData *)new spine::BoneData(arg1,(spine::String const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_BoneData(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_spine_BoneData__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_spine_BoneData__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of BoneData"); + return false; +} +SE_BIND_CTOR(js_new_spine_BoneData, __jsb_spine_BoneData_class, js_delete_spine_BoneData) + +static bool js_spine_BoneData_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_BoneData_index_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_index_get) + +static bool js_spine_BoneData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_BoneData_name_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_spine_BoneData_name_get) + +static bool js_spine_BoneData_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *)spine_BoneData_parent_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_spine_BoneData_parent_get) + +static bool js_spine_BoneData_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_length_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_length_set) + +static bool js_spine_BoneData_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_length_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_length_get) + +static bool js_spine_BoneData_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_x_set) + +static bool js_spine_BoneData_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_x_get) + +static bool js_spine_BoneData_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_y_set) + +static bool js_spine_BoneData_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_y_get) + +static bool js_spine_BoneData_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_rotation_set) + +static bool js_spine_BoneData_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_rotation_get) + +static bool js_spine_BoneData_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_scaleX_set) + +static bool js_spine_BoneData_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_scaleX_get) + +static bool js_spine_BoneData_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_scaleY_set) + +static bool js_spine_BoneData_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_scaleY_get) + +static bool js_spine_BoneData_shearX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_shearX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_shearX_set) + +static bool js_spine_BoneData_shearX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_shearX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_shearX_get) + +static bool js_spine_BoneData_shearY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_shearY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_shearY_set) + +static bool js_spine_BoneData_shearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_shearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_shearY_get) + +static bool js_spine_BoneData_transformMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::TransformMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_BoneData_transformMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_transformMode_set) + +static bool js_spine_BoneData_transformMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::TransformMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TransformMode)spine_BoneData_transformMode_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_spine_BoneData_transformMode_get) + +static bool js_spine_BoneData_skinRequired_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_skinRequired_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_skinRequired_set) + +static bool js_spine_BoneData_skinRequired_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_BoneData_skinRequired_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_skinRequired_get) + +static bool js_delete_spine_BoneData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_BoneData) + +bool js_register_spine_BoneData(se::Object* obj) { + auto* cls = se::Class::create("BoneData", obj, nullptr, _SE(js_new_spine_BoneData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("index", _SE(js_spine_BoneData_index_get), nullptr); + cls->defineProperty("name", _SE(js_spine_BoneData_name_get), nullptr); + cls->defineProperty("parent", _SE(js_spine_BoneData_parent_get), nullptr); + cls->defineProperty("length", _SE(js_spine_BoneData_length_get), _SE(js_spine_BoneData_length_set)); + cls->defineProperty("x", _SE(js_spine_BoneData_x_get), _SE(js_spine_BoneData_x_set)); + cls->defineProperty("y", _SE(js_spine_BoneData_y_get), _SE(js_spine_BoneData_y_set)); + cls->defineProperty("rotation", _SE(js_spine_BoneData_rotation_get), _SE(js_spine_BoneData_rotation_set)); + cls->defineProperty("scaleX", _SE(js_spine_BoneData_scaleX_get), _SE(js_spine_BoneData_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_BoneData_scaleY_get), _SE(js_spine_BoneData_scaleY_set)); + cls->defineProperty("shearX", _SE(js_spine_BoneData_shearX_get), _SE(js_spine_BoneData_shearX_set)); + cls->defineProperty("shearY", _SE(js_spine_BoneData_shearY_get), _SE(js_spine_BoneData_shearY_set)); + cls->defineProperty("transformMode", _SE(js_spine_BoneData_transformMode_get), _SE(js_spine_BoneData_transformMode_set)); + cls->defineProperty("skinRequired", _SE(js_spine_BoneData_skinRequired_get), _SE(js_spine_BoneData_skinRequired_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_BoneData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_BoneData_proto = cls->getProto(); + __jsb_spine_BoneData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ClippingAttachment_class = nullptr; +se::Object* __jsb_spine_ClippingAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ClippingAttachment) + +static bool js_new_spine_ClippingAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::ClippingAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::ClippingAttachment *)new spine::ClippingAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ClippingAttachment, __jsb_spine_ClippingAttachment_class, js_delete_spine_ClippingAttachment) + +static bool js_spine_ClippingAttachment_endSlot_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ClippingAttachment *arg1 = (spine::ClippingAttachment *) NULL ; + spine::SlotData *arg2 = (spine::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_ClippingAttachment_endSlot_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ClippingAttachment_endSlot_set) + +static bool js_spine_ClippingAttachment_endSlot_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ClippingAttachment *arg1 = (spine::ClippingAttachment *) NULL ; + spine::SlotData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SlotData *)spine_ClippingAttachment_endSlot_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_spine_ClippingAttachment_endSlot_get) + +static bool js_delete_spine_ClippingAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ClippingAttachment) + +bool js_register_spine_ClippingAttachment(se::Object* obj) { + auto* cls = se::Class::create("ClippingAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_ClippingAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("endSlot", _SE(js_spine_ClippingAttachment_endSlot_get), _SE(js_spine_ClippingAttachment_endSlot_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ClippingAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ClippingAttachment_proto = cls->getProto(); + __jsb_spine_ClippingAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Color_class = nullptr; +se::Object* __jsb_spine_Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Color) + +static bool js_new_spine_Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Color *result; + result = (spine::Color *)new spine::Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + spine::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Color *)new spine::Color(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_spine_Color__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_spine_Color__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Color"); + return false; +} +SE_BIND_CTOR(js_new_spine_Color, __jsb_spine_Color_class, js_delete_spine_Color) + +static bool js_spine_Color_set__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Color *) &(arg1)->set(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Color_set__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *arg2 = 0 ; + spine::Color temp2 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::Color *) &(arg1)->set((spine::Color 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; +} + +static bool js_spine_Color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_Color_set__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_spine_Color_set__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_Color_set) + +static bool js_spine_Color_add__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Color *) &(arg1)->add(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Color_add__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *arg2 = 0 ; + spine::Color temp2 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::Color *) &(arg1)->add((spine::Color 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; +} + +static bool js_spine_Color_add(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_Color_add__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_spine_Color_add__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_Color_add) + +static bool js_spine_Color_clamp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *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(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &(arg1)->clamp(); + + 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_spine_Color_clamp) + +static bool js_spine_Color_r_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->r, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_r_set) + +static bool js_spine_Color_r_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->r, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_r_get) + +static bool js_spine_Color_g_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->g, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_g_set) + +static bool js_spine_Color_g_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->g, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_g_get) + +static bool js_spine_Color_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_b_set) + +static bool js_spine_Color_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_b_get) + +static bool js_spine_Color_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_a_set) + +static bool js_spine_Color_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_a_get) + +static bool js_spine_Color_setFromColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *arg2 = 0 ; + spine::Color temp2 ; + spine::Color *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(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 = (spine::Color *) &spine_Color_setFromColor(arg1,(spine::Color 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_spine_Color_setFromColor) + +static bool js_delete_spine_Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Color) + +bool js_register_spine_Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_spine_Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("r", _SE(js_spine_Color_r_get), _SE(js_spine_Color_r_set)); + cls->defineProperty("g", _SE(js_spine_Color_g_get), _SE(js_spine_Color_g_set)); + cls->defineProperty("b", _SE(js_spine_Color_b_get), _SE(js_spine_Color_b_set)); + cls->defineProperty("a", _SE(js_spine_Color_a_get), _SE(js_spine_Color_a_set)); + + cls->defineFunction("set", _SE(js_spine_Color_set)); + cls->defineFunction("add", _SE(js_spine_Color_add)); + cls->defineFunction("clamp", _SE(js_spine_Color_clamp)); + cls->defineFunction("setFromColor", _SE(js_spine_Color_setFromColor)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Color_proto = cls->getProto(); + __jsb_spine_Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_CurveTimeline_class = nullptr; +se::Object* __jsb_spine_CurveTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_CurveTimeline) + +static bool js_delete_spine_CurveTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_CurveTimeline) + +static bool js_spine_CurveTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_getFrameCount) + +static bool js_spine_CurveTimeline_setLinear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setLinear(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_setLinear) + +static bool js_spine_CurveTimeline_setStepped(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setStepped(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_setStepped) + +static bool js_spine_CurveTimeline_setCurve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCurve(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_setCurve) + +static bool js_spine_CurveTimeline_getCurvePercent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + float result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (float)(arg1)->getCurvePercent(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_getCurvePercent) + +static bool js_spine_CurveTimeline_getCurveType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (float)(arg1)->getCurveType(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_getCurveType) + +bool js_register_spine_CurveTimeline(se::Object* obj) { + auto* cls = se::Class::create("CurveTimeline", obj, __jsb_spine_Timeline_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getFrameCount", _SE(js_spine_CurveTimeline_getFrameCount)); + cls->defineFunction("setLinear", _SE(js_spine_CurveTimeline_setLinear)); + cls->defineFunction("setStepped", _SE(js_spine_CurveTimeline_setStepped)); + cls->defineFunction("setCurve", _SE(js_spine_CurveTimeline_setCurve)); + cls->defineFunction("getCurvePercent", _SE(js_spine_CurveTimeline_getCurvePercent)); + cls->defineFunction("getCurveType", _SE(js_spine_CurveTimeline_getCurveType)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_CurveTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_CurveTimeline_proto = cls->getProto(); + __jsb_spine_CurveTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ColorTimeline_class = nullptr; +se::Object* __jsb_spine_ColorTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ColorTimeline) + +static bool js_new_spine_ColorTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::ColorTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::ColorTimeline *)new spine::ColorTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ColorTimeline, __jsb_spine_ColorTimeline_class, js_delete_spine_ColorTimeline) + +static bool js_spine_ColorTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_spine_ColorTimeline_setFrame) + +static bool js_spine_ColorTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_ColorTimeline_slotIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ColorTimeline_slotIndex_set) + +static bool js_spine_ColorTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_ColorTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_ColorTimeline_slotIndex_get) + +static bool js_spine_ColorTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_ColorTimeline_frames_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_spine_ColorTimeline_frames_get) + +static bool js_delete_spine_ColorTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ColorTimeline) + +bool js_register_spine_ColorTimeline(se::Object* obj) { + auto* cls = se::Class::create("ColorTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_ColorTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_ColorTimeline_slotIndex_get), _SE(js_spine_ColorTimeline_slotIndex_set)); + cls->defineProperty("frames", _SE(js_spine_ColorTimeline_frames_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_ColorTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ColorTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ColorTimeline_proto = cls->getProto(); + __jsb_spine_ColorTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_DeformTimeline_class = nullptr; +se::Object* __jsb_spine_DeformTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_DeformTimeline) + +static bool js_new_spine_DeformTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::DeformTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::DeformTimeline *)new spine::DeformTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_DeformTimeline, __jsb_spine_DeformTimeline_class, js_delete_spine_DeformTimeline) + +static bool js_spine_DeformTimeline_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::VertexAttachment *arg2 = (spine::VertexAttachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachment(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_DeformTimeline_setAttachment) + +static bool js_spine_DeformTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_DeformTimeline_slotIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_DeformTimeline_slotIndex_set) + +static bool js_spine_DeformTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_DeformTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_DeformTimeline_slotIndex_get) + +static bool js_spine_DeformTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_DeformTimeline_frames_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_spine_DeformTimeline_frames_get) + +static bool js_spine_DeformTimeline_frameVertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_DeformTimeline_frameVertices_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_spine_DeformTimeline_frameVertices_get) + +static bool js_spine_DeformTimeline_attachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::VertexAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::VertexAttachment *)spine_DeformTimeline_attachment_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_spine_DeformTimeline_attachment_get) + +static bool js_spine_DeformTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + int arg2 ; + float arg3 ; + ccstd::vector< float > *arg4 = 0 ; + ccstd::vector< float > temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + spine_DeformTimeline_setFrame(arg1,arg2,arg3,(ccstd::vector< float > const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_DeformTimeline_setFrame) + +static bool js_delete_spine_DeformTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_DeformTimeline) + +bool js_register_spine_DeformTimeline(se::Object* obj) { + auto* cls = se::Class::create("DeformTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_DeformTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_DeformTimeline_slotIndex_get), _SE(js_spine_DeformTimeline_slotIndex_set)); + cls->defineProperty("frames", _SE(js_spine_DeformTimeline_frames_get), nullptr); + cls->defineProperty("frameVertices", _SE(js_spine_DeformTimeline_frameVertices_get), nullptr); + cls->defineProperty("attachment", _SE(js_spine_DeformTimeline_attachment_get), nullptr); + + cls->defineFunction("setAttachment", _SE(js_spine_DeformTimeline_setAttachment)); + cls->defineFunction("setFrame", _SE(js_spine_DeformTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_DeformTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_DeformTimeline_proto = cls->getProto(); + __jsb_spine_DeformTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_DrawOrderTimeline_class = nullptr; +se::Object* __jsb_spine_DrawOrderTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_DrawOrderTimeline) + +static bool js_new_spine_DrawOrderTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::DrawOrderTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::DrawOrderTimeline *)new spine::DrawOrderTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_DrawOrderTimeline, __jsb_spine_DrawOrderTimeline_class, js_delete_spine_DrawOrderTimeline) + +static bool js_spine_DrawOrderTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_DrawOrderTimeline_getFrameCount) + +static bool js_spine_DrawOrderTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_DrawOrderTimeline_frames_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_spine_DrawOrderTimeline_frames_get) + +static bool js_spine_DrawOrderTimeline_drawOrders_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + spine::Vector< spine::Vector< int > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Vector< int > > *) &spine_DrawOrderTimeline_drawOrders_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_spine_DrawOrderTimeline_drawOrders_get) + +static bool js_spine_DrawOrderTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + ccstd::vector< int > *arg4 = 0 ; + ccstd::vector< int > temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + spine_DrawOrderTimeline_setFrame(arg1,SWIG_STD_MOVE(arg2),arg3,(ccstd::vector< int > const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_DrawOrderTimeline_setFrame) + +static bool js_delete_spine_DrawOrderTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_DrawOrderTimeline) + +bool js_register_spine_DrawOrderTimeline(se::Object* obj) { + auto* cls = se::Class::create("DrawOrderTimeline", obj, __jsb_spine_Timeline_proto, _SE(js_new_spine_DrawOrderTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frames", _SE(js_spine_DrawOrderTimeline_frames_get), nullptr); + cls->defineProperty("drawOrders", _SE(js_spine_DrawOrderTimeline_drawOrders_get), nullptr); + + cls->defineFunction("getFrameCount", _SE(js_spine_DrawOrderTimeline_getFrameCount)); + cls->defineFunction("setFrame", _SE(js_spine_DrawOrderTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_DrawOrderTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_DrawOrderTimeline_proto = cls->getProto(); + __jsb_spine_DrawOrderTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Event_class = nullptr; +se::Object* __jsb_spine_Event_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Event) + +static bool js_spine_Event_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + spine::EventData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::EventData *) &spine_Event_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_data_get) + +static bool js_spine_Event_intValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_intValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_intValue_set) + +static bool js_spine_Event_intValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_Event_intValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_intValue_get) + +static bool js_spine_Event_floatValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_floatValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_floatValue_set) + +static bool js_spine_Event_floatValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_floatValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_floatValue_get) + +static bool js_spine_Event_stringValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_Event_stringValue_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_stringValue_set) + +static bool js_spine_Event_stringValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Event_stringValue_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_spine_Event_stringValue_get) + +static bool js_spine_Event_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_time_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_time_get) + +static bool js_spine_Event_volume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_volume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_volume_set) + +static bool js_spine_Event_volume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_volume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_volume_get) + +static bool js_spine_Event_balance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_balance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_balance_set) + +static bool js_spine_Event_balance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_balance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_balance_get) + +static bool js_new_spine_Event(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + spine::EventData *arg2 = (spine::EventData *) NULL ; + spine::Event *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Event *)new_spine_Event(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Event, __jsb_spine_Event_class, js_delete_spine_Event) + +static bool js_delete_spine_Event(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Event) + +bool js_register_spine_Event(se::Object* obj) { + auto* cls = se::Class::create("Event", obj, nullptr, _SE(js_new_spine_Event)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Event_data_get), nullptr); + cls->defineProperty("intValue", _SE(js_spine_Event_intValue_get), _SE(js_spine_Event_intValue_set)); + cls->defineProperty("floatValue", _SE(js_spine_Event_floatValue_get), _SE(js_spine_Event_floatValue_set)); + cls->defineProperty("stringValue", _SE(js_spine_Event_stringValue_get), _SE(js_spine_Event_stringValue_set)); + cls->defineProperty("time", _SE(js_spine_Event_time_get), nullptr); + cls->defineProperty("volume", _SE(js_spine_Event_volume_get), _SE(js_spine_Event_volume_set)); + cls->defineProperty("balance", _SE(js_spine_Event_balance_get), _SE(js_spine_Event_balance_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Event)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Event_proto = cls->getProto(); + __jsb_spine_Event_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventData_class = nullptr; +se::Object* __jsb_spine_EventData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventData) + +static bool js_new_spine_EventData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::EventData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::EventData *)new spine::EventData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_EventData, __jsb_spine_EventData_class, js_delete_spine_EventData) + +static bool js_spine_EventData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_EventData_name_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_spine_EventData_name_get) + +static bool js_spine_EventData_intValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_intValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_intValue_set) + +static bool js_spine_EventData_intValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_EventData_intValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_intValue_get) + +static bool js_spine_EventData_floatValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_floatValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_floatValue_set) + +static bool js_spine_EventData_floatValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_EventData_floatValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_floatValue_get) + +static bool js_spine_EventData_stringValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_EventData_stringValue_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_stringValue_set) + +static bool js_spine_EventData_stringValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_EventData_stringValue_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_spine_EventData_stringValue_get) + +static bool js_spine_EventData_volume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_volume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_volume_set) + +static bool js_spine_EventData_volume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_EventData_volume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_volume_get) + +static bool js_spine_EventData_balance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_balance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_balance_set) + +static bool js_spine_EventData_balance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_EventData_balance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_balance_get) + +static bool js_spine_EventData_audioPath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_EventData_audioPath_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_audioPath_set) + +static bool js_spine_EventData_audioPath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_EventData_audioPath_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_spine_EventData_audioPath_get) + +static bool js_delete_spine_EventData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_EventData) + +bool js_register_spine_EventData(se::Object* obj) { + auto* cls = se::Class::create("EventData", obj, nullptr, _SE(js_new_spine_EventData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_EventData_name_get), nullptr); + cls->defineProperty("intValue", _SE(js_spine_EventData_intValue_get), _SE(js_spine_EventData_intValue_set)); + cls->defineProperty("floatValue", _SE(js_spine_EventData_floatValue_get), _SE(js_spine_EventData_floatValue_set)); + cls->defineProperty("stringValue", _SE(js_spine_EventData_stringValue_get), _SE(js_spine_EventData_stringValue_set)); + cls->defineProperty("volume", _SE(js_spine_EventData_volume_get), _SE(js_spine_EventData_volume_set)); + cls->defineProperty("balance", _SE(js_spine_EventData_balance_get), _SE(js_spine_EventData_balance_set)); + cls->defineProperty("audioPath", _SE(js_spine_EventData_audioPath_get), _SE(js_spine_EventData_audioPath_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_EventData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventData_proto = cls->getProto(); + __jsb_spine_EventData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventTimeline_class = nullptr; +se::Object* __jsb_spine_EventTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventTimeline) + +static bool js_new_spine_EventTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::EventTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::EventTimeline *)new spine::EventTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_EventTimeline, __jsb_spine_EventTimeline_class, js_delete_spine_EventTimeline) + +static bool js_delete_spine_EventTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_EventTimeline) + +static bool js_spine_EventTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + size_t arg2 ; + spine::Event *arg3 = (spine::Event *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_EventTimeline_setFrame) + +static bool js_spine_EventTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_EventTimeline_getFrameCount) + +static bool js_spine_EventTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + spine::Vector< float > result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_EventTimeline_frames_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_spine_EventTimeline_frames_get) + +static bool js_spine_EventTimeline_events_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + spine::Vector< spine::Event * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Event * > *) &spine_EventTimeline_events_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_spine_EventTimeline_events_get) + +bool js_register_spine_EventTimeline(se::Object* obj) { + auto* cls = se::Class::create("EventTimeline", obj, __jsb_spine_Timeline_proto, _SE(js_new_spine_EventTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frames", _SE(js_spine_EventTimeline_frames_get), nullptr); + cls->defineProperty("events", _SE(js_spine_EventTimeline_events_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_EventTimeline_setFrame)); + cls->defineFunction("getFrameCount", _SE(js_spine_EventTimeline_getFrameCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_EventTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventTimeline_proto = cls->getProto(); + __jsb_spine_EventTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ConstraintData_class = nullptr; +se::Object* __jsb_spine_ConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ConstraintData) + +static bool js_new_spine_ConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::ConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::ConstraintData *)new spine::ConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ConstraintData, __jsb_spine_ConstraintData_class, js_delete_spine_ConstraintData) + +static bool js_delete_spine_ConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ConstraintData) + +static bool js_spine_ConstraintData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_ConstraintData_name_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_spine_ConstraintData_name_get) + +static bool js_spine_ConstraintData_order_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + size_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_ConstraintData_order_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ConstraintData_order_set) + +static bool js_spine_ConstraintData_order_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + size_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_ConstraintData_order_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_ConstraintData_order_get) + +static bool js_spine_ConstraintData_skinRequired_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_ConstraintData_skinRequired_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ConstraintData_skinRequired_set) + +static bool js_spine_ConstraintData_skinRequired_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_ConstraintData_skinRequired_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_ConstraintData_skinRequired_get) + +bool js_register_spine_ConstraintData(se::Object* obj) { + auto* cls = se::Class::create("ConstraintData", obj, nullptr, _SE(js_new_spine_ConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_ConstraintData_name_get), nullptr); + cls->defineProperty("order", _SE(js_spine_ConstraintData_order_get), _SE(js_spine_ConstraintData_order_set)); + cls->defineProperty("skinRequired", _SE(js_spine_ConstraintData_skinRequired_get), _SE(js_spine_ConstraintData_skinRequired_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ConstraintData_proto = cls->getProto(); + __jsb_spine_ConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_IkConstraint_class = nullptr; +se::Object* __jsb_spine_IkConstraint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_IkConstraint) + +static bool js_spine_IkConstraint_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->apply(); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_apply) + +static bool js_spine_IkConstraint_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_update) + +static bool js_spine_IkConstraint_getOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_getOrder) + +static bool js_spine_IkConstraint_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::IkConstraintData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::IkConstraintData *) &spine_IkConstraint_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_data_get) + +static bool js_spine_IkConstraint_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_IkConstraint_bones_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_spine_IkConstraint_bones_get) + +static bool js_spine_IkConstraint_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_target_set) + +static bool js_spine_IkConstraint_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)spine_IkConstraint_target_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_spine_IkConstraint_target_get) + +static bool js_spine_IkConstraint_bendDirection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_bendDirection_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_bendDirection_set) + +static bool js_spine_IkConstraint_bendDirection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_IkConstraint_bendDirection_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_bendDirection_get) + +static bool js_spine_IkConstraint_compress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_compress_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_compress_set) + +static bool js_spine_IkConstraint_compress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraint_compress_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_compress_get) + +static bool js_spine_IkConstraint_stretch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_stretch_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_stretch_set) + +static bool js_spine_IkConstraint_stretch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraint_stretch_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_stretch_get) + +static bool js_spine_IkConstraint_mix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_mix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_mix_set) + +static bool js_spine_IkConstraint_mix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraint_mix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_mix_get) + +static bool js_spine_IkConstraint_softness_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_softness_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_softness_set) + +static bool js_spine_IkConstraint_softness_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraint_softness_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_softness_get) + +static bool js_spine_IkConstraint_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_active_set) + +static bool js_spine_IkConstraint_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraint_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_active_get) + +static bool js_spine_IkConstraint_apply1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + float arg3 ; + float arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + float arg8 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_apply1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_apply1) + +static bool js_spine_IkConstraint_apply2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + spine::Bone *arg3 = (spine::Bone *) NULL ; + float arg4 ; + float arg5 ; + int arg6 ; + bool arg7 ; + float arg8 ; + float arg9 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_apply2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_apply2) + +static bool js_new_spine_IkConstraint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::IkConstraint *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::IkConstraint *)new_spine_IkConstraint(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_IkConstraint, __jsb_spine_IkConstraint_class, js_delete_spine_IkConstraint) + +static bool js_delete_spine_IkConstraint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_IkConstraint) + +bool js_register_spine_IkConstraint(se::Object* obj) { + auto* cls = se::Class::create("IkConstraint", obj, nullptr, _SE(js_new_spine_IkConstraint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_IkConstraint_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_IkConstraint_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_IkConstraint_target_get), _SE(js_spine_IkConstraint_target_set)); + cls->defineProperty("bendDirection", _SE(js_spine_IkConstraint_bendDirection_get), _SE(js_spine_IkConstraint_bendDirection_set)); + cls->defineProperty("compress", _SE(js_spine_IkConstraint_compress_get), _SE(js_spine_IkConstraint_compress_set)); + cls->defineProperty("stretch", _SE(js_spine_IkConstraint_stretch_get), _SE(js_spine_IkConstraint_stretch_set)); + cls->defineProperty("mix", _SE(js_spine_IkConstraint_mix_get), _SE(js_spine_IkConstraint_mix_set)); + cls->defineProperty("softness", _SE(js_spine_IkConstraint_softness_get), _SE(js_spine_IkConstraint_softness_set)); + cls->defineProperty("active", _SE(js_spine_IkConstraint_active_get), _SE(js_spine_IkConstraint_active_set)); + + cls->defineFunction("apply", _SE(js_spine_IkConstraint_apply)); + cls->defineFunction("update", _SE(js_spine_IkConstraint_update)); + cls->defineFunction("getOrder", _SE(js_spine_IkConstraint_getOrder)); + cls->defineFunction("apply1", _SE(js_spine_IkConstraint_apply1)); + cls->defineFunction("apply2", _SE(js_spine_IkConstraint_apply2)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_IkConstraint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_IkConstraint_proto = cls->getProto(); + __jsb_spine_IkConstraint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_IkConstraintData_class = nullptr; +se::Object* __jsb_spine_IkConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_IkConstraintData) + +static bool js_new_spine_IkConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::IkConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::IkConstraintData *)new spine::IkConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_IkConstraintData, __jsb_spine_IkConstraintData_class, js_delete_spine_IkConstraintData) + +static bool js_spine_IkConstraintData_setTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::BoneData *arg2 = (spine::BoneData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTarget(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraintData_setTarget) + +static bool js_spine_IkConstraintData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_IkConstraintData_bones_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_spine_IkConstraintData_bones_get) + +static bool js_spine_IkConstraintData_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *)spine_IkConstraintData_target_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_spine_IkConstraintData_target_get) + +static bool js_spine_IkConstraintData_bendDirection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_bendDirection_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_bendDirection_set) + +static bool js_spine_IkConstraintData_bendDirection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_IkConstraintData_bendDirection_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_bendDirection_get) + +static bool js_spine_IkConstraintData_compress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_compress_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_compress_set) + +static bool js_spine_IkConstraintData_compress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraintData_compress_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_compress_get) + +static bool js_spine_IkConstraintData_stretch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_stretch_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_stretch_set) + +static bool js_spine_IkConstraintData_stretch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraintData_stretch_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_stretch_get) + +static bool js_spine_IkConstraintData_uniform_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_uniform_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_uniform_set) + +static bool js_spine_IkConstraintData_uniform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraintData_uniform_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_uniform_get) + +static bool js_spine_IkConstraintData_mix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_mix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_mix_set) + +static bool js_spine_IkConstraintData_mix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraintData_mix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_mix_get) + +static bool js_spine_IkConstraintData_softness_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_softness_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_softness_set) + +static bool js_spine_IkConstraintData_softness_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraintData_softness_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_softness_get) + +static bool js_delete_spine_IkConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_IkConstraintData) + +bool js_register_spine_IkConstraintData(se::Object* obj) { + auto* cls = se::Class::create("IkConstraintData", obj, __jsb_spine_ConstraintData_proto, _SE(js_new_spine_IkConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bones", _SE(js_spine_IkConstraintData_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_IkConstraintData_target_get), nullptr); + cls->defineProperty("bendDirection", _SE(js_spine_IkConstraintData_bendDirection_get), _SE(js_spine_IkConstraintData_bendDirection_set)); + cls->defineProperty("compress", _SE(js_spine_IkConstraintData_compress_get), _SE(js_spine_IkConstraintData_compress_set)); + cls->defineProperty("stretch", _SE(js_spine_IkConstraintData_stretch_get), _SE(js_spine_IkConstraintData_stretch_set)); + cls->defineProperty("uniform", _SE(js_spine_IkConstraintData_uniform_get), _SE(js_spine_IkConstraintData_uniform_set)); + cls->defineProperty("mix", _SE(js_spine_IkConstraintData_mix_get), _SE(js_spine_IkConstraintData_mix_set)); + cls->defineProperty("softness", _SE(js_spine_IkConstraintData_softness_get), _SE(js_spine_IkConstraintData_softness_set)); + + cls->defineFunction("setTarget", _SE(js_spine_IkConstraintData_setTarget)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_IkConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_IkConstraintData_proto = cls->getProto(); + __jsb_spine_IkConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_IkConstraintTimeline_class = nullptr; +se::Object* __jsb_spine_IkConstraintTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_IkConstraintTimeline) + +static bool js_new_spine_IkConstraintTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::IkConstraintTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::IkConstraintTimeline *)new spine::IkConstraintTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_IkConstraintTimeline, __jsb_spine_IkConstraintTimeline_class, js_delete_spine_IkConstraintTimeline) + +static bool js_spine_IkConstraintTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintTimeline *arg1 = (spine::IkConstraintTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + int arg6 ; + bool arg7 ; + bool arg8 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraintTimeline_setFrame) + +static bool js_delete_spine_IkConstraintTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_IkConstraintTimeline) + +bool js_register_spine_IkConstraintTimeline(se::Object* obj) { + auto* cls = se::Class::create("IkConstraintTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_IkConstraintTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_IkConstraintTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_IkConstraintTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_IkConstraintTimeline_proto = cls->getProto(); + __jsb_spine_IkConstraintTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_MeshAttachment_class = nullptr; +se::Object* __jsb_spine_MeshAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_MeshAttachment) + +static bool js_new_spine_MeshAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::MeshAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::MeshAttachment *)new spine::MeshAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_MeshAttachment, __jsb_spine_MeshAttachment_class, js_delete_spine_MeshAttachment) + +static bool js_delete_spine_MeshAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_MeshAttachment) + +static bool js_spine_MeshAttachment_updateUVs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateUVs(); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_updateUVs) + +static bool js_spine_MeshAttachment_getRegionU(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionU(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionU) + +static bool js_spine_MeshAttachment_setRegionU(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionU(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionU) + +static bool js_spine_MeshAttachment_getRegionV(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionV(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionV) + +static bool js_spine_MeshAttachment_setRegionV(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionV(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionV) + +static bool js_spine_MeshAttachment_getRegionU2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionU2(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionU2) + +static bool js_spine_MeshAttachment_setRegionU2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionU2(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionU2) + +static bool js_spine_MeshAttachment_getRegionV2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionV2(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionV2) + +static bool js_spine_MeshAttachment_setRegionV2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionV2(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionV2) + +static bool js_spine_MeshAttachment_getRegionRotate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->getRegionRotate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionRotate) + +static bool js_spine_MeshAttachment_setRegionRotate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionRotate(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionRotate) + +static bool js_spine_MeshAttachment_getRegionDegrees(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getRegionDegrees(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionDegrees) + +static bool js_spine_MeshAttachment_setRegionDegrees(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionDegrees(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionDegrees) + +static bool js_spine_MeshAttachment_getRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOffsetX) + +static bool js_spine_MeshAttachment_setRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetX(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOffsetX) + +static bool js_spine_MeshAttachment_getRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOffsetY) + +static bool js_spine_MeshAttachment_setRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetY(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOffsetY) + +static bool js_spine_MeshAttachment_getRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionWidth) + +static bool js_spine_MeshAttachment_setRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionWidth) + +static bool js_spine_MeshAttachment_getRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionHeight) + +static bool js_spine_MeshAttachment_setRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionHeight) + +static bool js_spine_MeshAttachment_getRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOriginalWidth) + +static bool js_spine_MeshAttachment_setRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOriginalWidth) + +static bool js_spine_MeshAttachment_getRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOriginalHeight) + +static bool js_spine_MeshAttachment_setRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOriginalHeight) + +static bool js_spine_MeshAttachment_getParentMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::MeshAttachment *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(s); + if (nullptr == arg1) return true; + result = (spine::MeshAttachment *)(arg1)->getParentMesh(); + + 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_spine_MeshAttachment_getParentMesh) + +static bool js_spine_MeshAttachment_setParentMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::MeshAttachment *arg2 = (spine::MeshAttachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParentMesh(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setParentMesh) + +static bool js_spine_MeshAttachment_newLinkedMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::MeshAttachment *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(s); + if (nullptr == arg1) return true; + result = (spine::MeshAttachment *)(arg1)->newLinkedMesh(); + + 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_spine_MeshAttachment_newLinkedMesh) + +static bool js_spine_MeshAttachment_path_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_MeshAttachment_path_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_path_set) + +static bool js_spine_MeshAttachment_path_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_MeshAttachment_path_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_spine_MeshAttachment_path_get) + +static bool js_spine_MeshAttachment_regionUVs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_MeshAttachment_regionUVs_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_spine_MeshAttachment_regionUVs_get) + +static bool js_spine_MeshAttachment_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_MeshAttachment_uvs_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_spine_MeshAttachment_uvs_get) + +static bool js_spine_MeshAttachment_triangles_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< unsigned short > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< unsigned short > *) &spine_MeshAttachment_triangles_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_spine_MeshAttachment_triangles_get) + +static bool js_spine_MeshAttachment_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_MeshAttachment_color_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_spine_MeshAttachment_color_get) + +static bool js_spine_MeshAttachment_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_MeshAttachment_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_width_set) + +static bool js_spine_MeshAttachment_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_MeshAttachment_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_MeshAttachment_width_get) + +static bool js_spine_MeshAttachment_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_MeshAttachment_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_height_set) + +static bool js_spine_MeshAttachment_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_MeshAttachment_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_MeshAttachment_height_get) + +static bool js_spine_MeshAttachment_hullLength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_MeshAttachment_hullLength_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_hullLength_set) + +static bool js_spine_MeshAttachment_hullLength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_MeshAttachment_hullLength_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_MeshAttachment_hullLength_get) + +static bool js_spine_MeshAttachment_edges_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< unsigned short > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< unsigned short > *) &spine_MeshAttachment_edges_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_spine_MeshAttachment_edges_get) + +bool js_register_spine_MeshAttachment(se::Object* obj) { + auto* cls = se::Class::create("MeshAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_MeshAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("path", _SE(js_spine_MeshAttachment_path_get), _SE(js_spine_MeshAttachment_path_set)); + cls->defineProperty("regionUVs", _SE(js_spine_MeshAttachment_regionUVs_get), nullptr); + cls->defineProperty("uvs", _SE(js_spine_MeshAttachment_uvs_get), nullptr); + cls->defineProperty("triangles", _SE(js_spine_MeshAttachment_triangles_get), nullptr); + cls->defineProperty("color", _SE(js_spine_MeshAttachment_color_get), nullptr); + cls->defineProperty("width", _SE(js_spine_MeshAttachment_width_get), _SE(js_spine_MeshAttachment_width_set)); + cls->defineProperty("height", _SE(js_spine_MeshAttachment_height_get), _SE(js_spine_MeshAttachment_height_set)); + cls->defineProperty("hullLength", _SE(js_spine_MeshAttachment_hullLength_get), _SE(js_spine_MeshAttachment_hullLength_set)); + cls->defineProperty("edges", _SE(js_spine_MeshAttachment_edges_get), nullptr); + + cls->defineFunction("updateUVs", _SE(js_spine_MeshAttachment_updateUVs)); + cls->defineFunction("getRegionU", _SE(js_spine_MeshAttachment_getRegionU)); + cls->defineFunction("setRegionU", _SE(js_spine_MeshAttachment_setRegionU)); + cls->defineFunction("getRegionV", _SE(js_spine_MeshAttachment_getRegionV)); + cls->defineFunction("setRegionV", _SE(js_spine_MeshAttachment_setRegionV)); + cls->defineFunction("getRegionU2", _SE(js_spine_MeshAttachment_getRegionU2)); + cls->defineFunction("setRegionU2", _SE(js_spine_MeshAttachment_setRegionU2)); + cls->defineFunction("getRegionV2", _SE(js_spine_MeshAttachment_getRegionV2)); + cls->defineFunction("setRegionV2", _SE(js_spine_MeshAttachment_setRegionV2)); + cls->defineFunction("getRegionRotate", _SE(js_spine_MeshAttachment_getRegionRotate)); + cls->defineFunction("setRegionRotate", _SE(js_spine_MeshAttachment_setRegionRotate)); + cls->defineFunction("getRegionDegrees", _SE(js_spine_MeshAttachment_getRegionDegrees)); + cls->defineFunction("setRegionDegrees", _SE(js_spine_MeshAttachment_setRegionDegrees)); + cls->defineFunction("getRegionOffsetX", _SE(js_spine_MeshAttachment_getRegionOffsetX)); + cls->defineFunction("setRegionOffsetX", _SE(js_spine_MeshAttachment_setRegionOffsetX)); + cls->defineFunction("getRegionOffsetY", _SE(js_spine_MeshAttachment_getRegionOffsetY)); + cls->defineFunction("setRegionOffsetY", _SE(js_spine_MeshAttachment_setRegionOffsetY)); + cls->defineFunction("getRegionWidth", _SE(js_spine_MeshAttachment_getRegionWidth)); + cls->defineFunction("setRegionWidth", _SE(js_spine_MeshAttachment_setRegionWidth)); + cls->defineFunction("getRegionHeight", _SE(js_spine_MeshAttachment_getRegionHeight)); + cls->defineFunction("setRegionHeight", _SE(js_spine_MeshAttachment_setRegionHeight)); + cls->defineFunction("getRegionOriginalWidth", _SE(js_spine_MeshAttachment_getRegionOriginalWidth)); + cls->defineFunction("setRegionOriginalWidth", _SE(js_spine_MeshAttachment_setRegionOriginalWidth)); + cls->defineFunction("getRegionOriginalHeight", _SE(js_spine_MeshAttachment_getRegionOriginalHeight)); + cls->defineFunction("setRegionOriginalHeight", _SE(js_spine_MeshAttachment_setRegionOriginalHeight)); + cls->defineFunction("getParentMesh", _SE(js_spine_MeshAttachment_getParentMesh)); + cls->defineFunction("setParentMesh", _SE(js_spine_MeshAttachment_setParentMesh)); + cls->defineFunction("newLinkedMesh", _SE(js_spine_MeshAttachment_newLinkedMesh)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_MeshAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_MeshAttachment_proto = cls->getProto(); + __jsb_spine_MeshAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathAttachment_class = nullptr; +se::Object* __jsb_spine_PathAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathAttachment) + +static bool js_new_spine_PathAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::PathAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::PathAttachment *)new spine::PathAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathAttachment, __jsb_spine_PathAttachment_class, js_delete_spine_PathAttachment) + +static bool js_spine_PathAttachment_lengths_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_PathAttachment_lengths_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_spine_PathAttachment_lengths_get) + +static bool js_spine_PathAttachment_closed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathAttachment_closed_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathAttachment_closed_set) + +static bool js_spine_PathAttachment_closed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_PathAttachment_closed_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathAttachment_closed_get) + +static bool js_spine_PathAttachment_constantSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathAttachment_constantSpeed_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathAttachment_constantSpeed_set) + +static bool js_spine_PathAttachment_constantSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_PathAttachment_constantSpeed_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathAttachment_constantSpeed_get) + +static bool js_delete_spine_PathAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathAttachment) + +bool js_register_spine_PathAttachment(se::Object* obj) { + auto* cls = se::Class::create("PathAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_PathAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("lengths", _SE(js_spine_PathAttachment_lengths_get), nullptr); + cls->defineProperty("closed", _SE(js_spine_PathAttachment_closed_get), _SE(js_spine_PathAttachment_closed_set)); + cls->defineProperty("constantSpeed", _SE(js_spine_PathAttachment_constantSpeed_get), _SE(js_spine_PathAttachment_constantSpeed_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathAttachment_proto = cls->getProto(); + __jsb_spine_PathAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraint_class = nullptr; +se::Object* __jsb_spine_PathConstraint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraint) + +static bool js_spine_PathConstraint_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->apply(); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraint_apply) + +static bool js_spine_PathConstraint_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraint_update) + +static bool js_spine_PathConstraint_getOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraint_getOrder) + +static bool js_spine_PathConstraint_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::PathConstraintData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::PathConstraintData *) &spine_PathConstraint_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_data_get) + +static bool js_spine_PathConstraint_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_PathConstraint_bones_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_spine_PathConstraint_bones_get) + +static bool js_spine_PathConstraint_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::Slot *arg2 = (spine::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_target_set) + +static bool js_spine_PathConstraint_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::Slot *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Slot *)spine_PathConstraint_target_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_spine_PathConstraint_target_get) + +static bool js_spine_PathConstraint_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_position_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_position_set) + +static bool js_spine_PathConstraint_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_position_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_position_get) + +static bool js_spine_PathConstraint_spacing_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_spacing_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_spacing_set) + +static bool js_spine_PathConstraint_spacing_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_spacing_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_spacing_get) + +static bool js_spine_PathConstraint_rotateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_rotateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_rotateMix_set) + +static bool js_spine_PathConstraint_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_rotateMix_get) + +static bool js_spine_PathConstraint_translateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_translateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_translateMix_set) + +static bool js_spine_PathConstraint_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_translateMix_get) + +static bool js_spine_PathConstraint_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_active_set) + +static bool js_spine_PathConstraint_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_PathConstraint_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_active_get) + +static bool js_new_spine_PathConstraint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::PathConstraint *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraint *)new_spine_PathConstraint(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraint, __jsb_spine_PathConstraint_class, js_delete_spine_PathConstraint) + +static bool js_delete_spine_PathConstraint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraint) + +bool js_register_spine_PathConstraint(se::Object* obj) { + auto* cls = se::Class::create("PathConstraint", obj, nullptr, _SE(js_new_spine_PathConstraint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_PathConstraint_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_PathConstraint_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_PathConstraint_target_get), _SE(js_spine_PathConstraint_target_set)); + cls->defineProperty("position", _SE(js_spine_PathConstraint_position_get), _SE(js_spine_PathConstraint_position_set)); + cls->defineProperty("spacing", _SE(js_spine_PathConstraint_spacing_get), _SE(js_spine_PathConstraint_spacing_set)); + cls->defineProperty("rotateMix", _SE(js_spine_PathConstraint_rotateMix_get), _SE(js_spine_PathConstraint_rotateMix_set)); + cls->defineProperty("translateMix", _SE(js_spine_PathConstraint_translateMix_get), _SE(js_spine_PathConstraint_translateMix_set)); + cls->defineProperty("active", _SE(js_spine_PathConstraint_active_get), _SE(js_spine_PathConstraint_active_set)); + + cls->defineFunction("apply", _SE(js_spine_PathConstraint_apply)); + cls->defineFunction("update", _SE(js_spine_PathConstraint_update)); + cls->defineFunction("getOrder", _SE(js_spine_PathConstraint_getOrder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraint_proto = cls->getProto(); + __jsb_spine_PathConstraint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintData_class = nullptr; +se::Object* __jsb_spine_PathConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintData) + +static bool js_new_spine_PathConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::PathConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::PathConstraintData *)new spine::PathConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintData, __jsb_spine_PathConstraintData_class, js_delete_spine_PathConstraintData) + +static bool js_spine_PathConstraintData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_PathConstraintData_bones_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_spine_PathConstraintData_bones_get) + +static bool js_spine_PathConstraintData_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SlotData *arg2 = (spine::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_target_set) + +static bool js_spine_PathConstraintData_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SlotData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SlotData *)spine_PathConstraintData_target_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_spine_PathConstraintData_target_get) + +static bool js_spine_PathConstraintData_positionMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::PositionMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_PathConstraintData_positionMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_positionMode_set) + +static bool js_spine_PathConstraintData_positionMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::PositionMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::PositionMode)spine_PathConstraintData_positionMode_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_spine_PathConstraintData_positionMode_get) + +static bool js_spine_PathConstraintData_spacingMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SpacingMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_PathConstraintData_spacingMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_spacingMode_set) + +static bool js_spine_PathConstraintData_spacingMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SpacingMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SpacingMode)spine_PathConstraintData_spacingMode_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_spine_PathConstraintData_spacingMode_get) + +static bool js_spine_PathConstraintData_rotateMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::RotateMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_PathConstraintData_rotateMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_rotateMode_set) + +static bool js_spine_PathConstraintData_rotateMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::RotateMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::RotateMode)spine_PathConstraintData_rotateMode_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_spine_PathConstraintData_rotateMode_get) + +static bool js_spine_PathConstraintData_offsetRotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_offsetRotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_offsetRotation_set) + +static bool js_spine_PathConstraintData_offsetRotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_offsetRotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_offsetRotation_get) + +static bool js_spine_PathConstraintData_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_position_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_position_set) + +static bool js_spine_PathConstraintData_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_position_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_position_get) + +static bool js_spine_PathConstraintData_spacing_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_spacing_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_spacing_set) + +static bool js_spine_PathConstraintData_spacing_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_spacing_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_spacing_get) + +static bool js_spine_PathConstraintData_rotateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_rotateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_rotateMix_set) + +static bool js_spine_PathConstraintData_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_rotateMix_get) + +static bool js_spine_PathConstraintData_translateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_translateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_translateMix_set) + +static bool js_spine_PathConstraintData_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_translateMix_get) + +static bool js_delete_spine_PathConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintData) + +bool js_register_spine_PathConstraintData(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintData", obj, __jsb_spine_ConstraintData_proto, _SE(js_new_spine_PathConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bones", _SE(js_spine_PathConstraintData_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_PathConstraintData_target_get), _SE(js_spine_PathConstraintData_target_set)); + cls->defineProperty("positionMode", _SE(js_spine_PathConstraintData_positionMode_get), _SE(js_spine_PathConstraintData_positionMode_set)); + cls->defineProperty("spacingMode", _SE(js_spine_PathConstraintData_spacingMode_get), _SE(js_spine_PathConstraintData_spacingMode_set)); + cls->defineProperty("rotateMode", _SE(js_spine_PathConstraintData_rotateMode_get), _SE(js_spine_PathConstraintData_rotateMode_set)); + cls->defineProperty("offsetRotation", _SE(js_spine_PathConstraintData_offsetRotation_get), _SE(js_spine_PathConstraintData_offsetRotation_set)); + cls->defineProperty("position", _SE(js_spine_PathConstraintData_position_get), _SE(js_spine_PathConstraintData_position_set)); + cls->defineProperty("spacing", _SE(js_spine_PathConstraintData_spacing_get), _SE(js_spine_PathConstraintData_spacing_set)); + cls->defineProperty("rotateMix", _SE(js_spine_PathConstraintData_rotateMix_get), _SE(js_spine_PathConstraintData_rotateMix_set)); + cls->defineProperty("translateMix", _SE(js_spine_PathConstraintData_translateMix_get), _SE(js_spine_PathConstraintData_translateMix_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintData_proto = cls->getProto(); + __jsb_spine_PathConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintMixTimeline_class = nullptr; +se::Object* __jsb_spine_PathConstraintMixTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintMixTimeline) + +static bool js_new_spine_PathConstraintMixTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PathConstraintMixTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraintMixTimeline *)new spine::PathConstraintMixTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintMixTimeline, __jsb_spine_PathConstraintMixTimeline_class, js_delete_spine_PathConstraintMixTimeline) + +static bool js_delete_spine_PathConstraintMixTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintMixTimeline) + +bool js_register_spine_PathConstraintMixTimeline(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintMixTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_PathConstraintMixTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintMixTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintMixTimeline_proto = cls->getProto(); + __jsb_spine_PathConstraintMixTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintPositionTimeline_class = nullptr; +se::Object* __jsb_spine_PathConstraintPositionTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintPositionTimeline) + +static bool js_new_spine_PathConstraintPositionTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PathConstraintPositionTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraintPositionTimeline *)new spine::PathConstraintPositionTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintPositionTimeline, __jsb_spine_PathConstraintPositionTimeline_class, js_delete_spine_PathConstraintPositionTimeline) + +static bool js_delete_spine_PathConstraintPositionTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintPositionTimeline) + +static bool js_spine_PathConstraintPositionTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintPositionTimeline *arg1 = (spine::PathConstraintPositionTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraintPositionTimeline_setFrame) + +bool js_register_spine_PathConstraintPositionTimeline(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintPositionTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_PathConstraintPositionTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_PathConstraintPositionTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintPositionTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintPositionTimeline_proto = cls->getProto(); + __jsb_spine_PathConstraintPositionTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintSpacingTimeline_class = nullptr; +se::Object* __jsb_spine_PathConstraintSpacingTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintSpacingTimeline) + +static bool js_new_spine_PathConstraintSpacingTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PathConstraintSpacingTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraintSpacingTimeline *)new spine::PathConstraintSpacingTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintSpacingTimeline, __jsb_spine_PathConstraintSpacingTimeline_class, js_delete_spine_PathConstraintSpacingTimeline) + +static bool js_delete_spine_PathConstraintSpacingTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintSpacingTimeline) + +bool js_register_spine_PathConstraintSpacingTimeline(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintSpacingTimeline", obj, __jsb_spine_PathConstraintPositionTimeline_proto, _SE(js_new_spine_PathConstraintSpacingTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintSpacingTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintSpacingTimeline_proto = cls->getProto(); + __jsb_spine_PathConstraintSpacingTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PointAttachment_class = nullptr; +se::Object* __jsb_spine_PointAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PointAttachment) + +static bool js_new_spine_PointAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::PointAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::PointAttachment *)new spine::PointAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PointAttachment, __jsb_spine_PointAttachment_class, js_delete_spine_PointAttachment) + +static bool js_spine_PointAttachment_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PointAttachment_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PointAttachment_x_set) + +static bool js_spine_PointAttachment_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PointAttachment_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PointAttachment_x_get) + +static bool js_spine_PointAttachment_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PointAttachment_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PointAttachment_y_set) + +static bool js_spine_PointAttachment_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PointAttachment_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PointAttachment_y_get) + +static bool js_spine_PointAttachment_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PointAttachment_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PointAttachment_rotation_set) + +static bool js_spine_PointAttachment_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PointAttachment_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PointAttachment_rotation_get) + +static bool js_spine_PointAttachment_computeWorldRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine_PointAttachment_computeWorldRotation(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_PointAttachment_computeWorldRotation) + +static bool js_delete_spine_PointAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PointAttachment) + +bool js_register_spine_PointAttachment(se::Object* obj) { + auto* cls = se::Class::create("PointAttachment", obj, __jsb_spine_Attachment_proto, _SE(js_new_spine_PointAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_spine_PointAttachment_x_get), _SE(js_spine_PointAttachment_x_set)); + cls->defineProperty("y", _SE(js_spine_PointAttachment_y_get), _SE(js_spine_PointAttachment_y_set)); + cls->defineProperty("rotation", _SE(js_spine_PointAttachment_rotation_get), _SE(js_spine_PointAttachment_rotation_set)); + + cls->defineFunction("computeWorldRotation", _SE(js_spine_PointAttachment_computeWorldRotation)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PointAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PointAttachment_proto = cls->getProto(); + __jsb_spine_PointAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_RegionAttachment_class = nullptr; +se::Object* __jsb_spine_RegionAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_RegionAttachment) + +static bool js_new_spine_RegionAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::RegionAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::RegionAttachment *)new spine::RegionAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_RegionAttachment, __jsb_spine_RegionAttachment_class, js_delete_spine_RegionAttachment) + +static bool js_spine_RegionAttachment_updateOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateOffset(); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_updateOffset) + +static bool js_spine_RegionAttachment_setUVs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + bool arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUVs(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setUVs) + +static bool js_spine_RegionAttachment_getRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOffsetX) + +static bool js_spine_RegionAttachment_setRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetX(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOffsetX) + +static bool js_spine_RegionAttachment_getRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOffsetY) + +static bool js_spine_RegionAttachment_setRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetY(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOffsetY) + +static bool js_spine_RegionAttachment_getRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionWidth) + +static bool js_spine_RegionAttachment_setRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionWidth) + +static bool js_spine_RegionAttachment_getRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionHeight) + +static bool js_spine_RegionAttachment_setRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionHeight) + +static bool js_spine_RegionAttachment_getRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOriginalWidth) + +static bool js_spine_RegionAttachment_setRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOriginalWidth) + +static bool js_spine_RegionAttachment_getRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOriginalHeight) + +static bool js_spine_RegionAttachment_setRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOriginalHeight) + +static bool js_spine_RegionAttachment_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_x_set) + +static bool js_spine_RegionAttachment_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_x_get) + +static bool js_spine_RegionAttachment_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_y_set) + +static bool js_spine_RegionAttachment_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_y_get) + +static bool js_spine_RegionAttachment_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_scaleX_set) + +static bool js_spine_RegionAttachment_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_scaleX_get) + +static bool js_spine_RegionAttachment_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_scaleY_set) + +static bool js_spine_RegionAttachment_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_scaleY_get) + +static bool js_spine_RegionAttachment_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_rotation_set) + +static bool js_spine_RegionAttachment_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_rotation_get) + +static bool js_spine_RegionAttachment_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_width_set) + +static bool js_spine_RegionAttachment_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_width_get) + +static bool js_spine_RegionAttachment_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_height_set) + +static bool js_spine_RegionAttachment_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_height_get) + +static bool js_spine_RegionAttachment_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_RegionAttachment_color_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_spine_RegionAttachment_color_get) + +static bool js_spine_RegionAttachment_path_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_RegionAttachment_path_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_path_set) + +static bool js_spine_RegionAttachment_path_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_RegionAttachment_path_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_spine_RegionAttachment_path_get) + +static bool js_spine_RegionAttachment_rendererObject_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + void *arg2 = (void *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_rendererObject_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_rendererObject_set) + +static bool js_spine_RegionAttachment_rendererObject_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + void *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (void *)spine_RegionAttachment_rendererObject_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_spine_RegionAttachment_rendererObject_get) + +static bool js_spine_RegionAttachment_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_RegionAttachment_offset_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_spine_RegionAttachment_offset_get) + +static bool js_spine_RegionAttachment_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_RegionAttachment_uvs_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_spine_RegionAttachment_uvs_get) + +static bool js_delete_spine_RegionAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_RegionAttachment) + +bool js_register_spine_RegionAttachment(se::Object* obj) { + auto* cls = se::Class::create("RegionAttachment", obj, __jsb_spine_Attachment_proto, _SE(js_new_spine_RegionAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_spine_RegionAttachment_x_get), _SE(js_spine_RegionAttachment_x_set)); + cls->defineProperty("y", _SE(js_spine_RegionAttachment_y_get), _SE(js_spine_RegionAttachment_y_set)); + cls->defineProperty("scaleX", _SE(js_spine_RegionAttachment_scaleX_get), _SE(js_spine_RegionAttachment_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_RegionAttachment_scaleY_get), _SE(js_spine_RegionAttachment_scaleY_set)); + cls->defineProperty("rotation", _SE(js_spine_RegionAttachment_rotation_get), _SE(js_spine_RegionAttachment_rotation_set)); + cls->defineProperty("width", _SE(js_spine_RegionAttachment_width_get), _SE(js_spine_RegionAttachment_width_set)); + cls->defineProperty("height", _SE(js_spine_RegionAttachment_height_get), _SE(js_spine_RegionAttachment_height_set)); + cls->defineProperty("color", _SE(js_spine_RegionAttachment_color_get), nullptr); + cls->defineProperty("path", _SE(js_spine_RegionAttachment_path_get), _SE(js_spine_RegionAttachment_path_set)); + cls->defineProperty("rendererObject", _SE(js_spine_RegionAttachment_rendererObject_get), _SE(js_spine_RegionAttachment_rendererObject_set)); + cls->defineProperty("offset", _SE(js_spine_RegionAttachment_offset_get), nullptr); + cls->defineProperty("uvs", _SE(js_spine_RegionAttachment_uvs_get), nullptr); + + cls->defineFunction("updateOffset", _SE(js_spine_RegionAttachment_updateOffset)); + cls->defineFunction("setUVs", _SE(js_spine_RegionAttachment_setUVs)); + cls->defineFunction("getRegionOffsetX", _SE(js_spine_RegionAttachment_getRegionOffsetX)); + cls->defineFunction("setRegionOffsetX", _SE(js_spine_RegionAttachment_setRegionOffsetX)); + cls->defineFunction("getRegionOffsetY", _SE(js_spine_RegionAttachment_getRegionOffsetY)); + cls->defineFunction("setRegionOffsetY", _SE(js_spine_RegionAttachment_setRegionOffsetY)); + cls->defineFunction("getRegionWidth", _SE(js_spine_RegionAttachment_getRegionWidth)); + cls->defineFunction("setRegionWidth", _SE(js_spine_RegionAttachment_setRegionWidth)); + cls->defineFunction("getRegionHeight", _SE(js_spine_RegionAttachment_getRegionHeight)); + cls->defineFunction("setRegionHeight", _SE(js_spine_RegionAttachment_setRegionHeight)); + cls->defineFunction("getRegionOriginalWidth", _SE(js_spine_RegionAttachment_getRegionOriginalWidth)); + cls->defineFunction("setRegionOriginalWidth", _SE(js_spine_RegionAttachment_setRegionOriginalWidth)); + cls->defineFunction("getRegionOriginalHeight", _SE(js_spine_RegionAttachment_getRegionOriginalHeight)); + cls->defineFunction("setRegionOriginalHeight", _SE(js_spine_RegionAttachment_setRegionOriginalHeight)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_RegionAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_RegionAttachment_proto = cls->getProto(); + __jsb_spine_RegionAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TranslateTimeline_class = nullptr; +se::Object* __jsb_spine_TranslateTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TranslateTimeline) + +static bool js_new_spine_TranslateTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::TranslateTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TranslateTimeline *)new spine::TranslateTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TranslateTimeline, __jsb_spine_TranslateTimeline_class, js_delete_spine_TranslateTimeline) + +static bool js_delete_spine_TranslateTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TranslateTimeline) + +static bool js_spine_TranslateTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TranslateTimeline *arg1 = (spine::TranslateTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_spine_TranslateTimeline_setFrame) + +bool js_register_spine_TranslateTimeline(se::Object* obj) { + auto* cls = se::Class::create("TranslateTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_TranslateTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_TranslateTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TranslateTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TranslateTimeline_proto = cls->getProto(); + __jsb_spine_TranslateTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TwoColorTimeline_class = nullptr; +se::Object* __jsb_spine_TwoColorTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TwoColorTimeline) + +static bool js_new_spine_TwoColorTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::TwoColorTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TwoColorTimeline *)new spine::TwoColorTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TwoColorTimeline, __jsb_spine_TwoColorTimeline_class, js_delete_spine_TwoColorTimeline) + +static bool js_spine_TwoColorTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TwoColorTimeline *arg1 = (spine::TwoColorTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + float arg10 ; + + if(argc != 9) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 9); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} +SE_BIND_FUNC(js_spine_TwoColorTimeline_setFrame) + +static bool js_spine_TwoColorTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TwoColorTimeline *arg1 = (spine::TwoColorTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TwoColorTimeline_slotIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TwoColorTimeline_slotIndex_set) + +static bool js_spine_TwoColorTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TwoColorTimeline *arg1 = (spine::TwoColorTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_TwoColorTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TwoColorTimeline_slotIndex_get) + +static bool js_delete_spine_TwoColorTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TwoColorTimeline) + +bool js_register_spine_TwoColorTimeline(se::Object* obj) { + auto* cls = se::Class::create("TwoColorTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_TwoColorTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_TwoColorTimeline_slotIndex_get), _SE(js_spine_TwoColorTimeline_slotIndex_set)); + + cls->defineFunction("setFrame", _SE(js_spine_TwoColorTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TwoColorTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TwoColorTimeline_proto = cls->getProto(); + __jsb_spine_TwoColorTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_RotateTimeline_class = nullptr; +se::Object* __jsb_spine_RotateTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_RotateTimeline) + +static bool js_new_spine_RotateTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::RotateTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::RotateTimeline *)new spine::RotateTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_RotateTimeline, __jsb_spine_RotateTimeline_class, js_delete_spine_RotateTimeline) + +static bool js_spine_RotateTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_RotateTimeline_setFrame) + +static bool js_spine_RotateTimeline_boneIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RotateTimeline_boneIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RotateTimeline_boneIndex_set) + +static bool js_spine_RotateTimeline_boneIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_RotateTimeline_boneIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RotateTimeline_boneIndex_get) + +static bool js_spine_RotateTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_RotateTimeline_frames_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_spine_RotateTimeline_frames_get) + +static bool js_delete_spine_RotateTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_RotateTimeline) + +bool js_register_spine_RotateTimeline(se::Object* obj) { + auto* cls = se::Class::create("RotateTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_RotateTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("boneIndex", _SE(js_spine_RotateTimeline_boneIndex_get), _SE(js_spine_RotateTimeline_boneIndex_set)); + cls->defineProperty("frames", _SE(js_spine_RotateTimeline_frames_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_RotateTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_RotateTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_RotateTimeline_proto = cls->getProto(); + __jsb_spine_RotateTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ScaleTimeline_class = nullptr; +se::Object* __jsb_spine_ScaleTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ScaleTimeline) + +static bool js_new_spine_ScaleTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::ScaleTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::ScaleTimeline *)new spine::ScaleTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ScaleTimeline, __jsb_spine_ScaleTimeline_class, js_delete_spine_ScaleTimeline) + +static bool js_delete_spine_ScaleTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ScaleTimeline) + +bool js_register_spine_ScaleTimeline(se::Object* obj) { + auto* cls = se::Class::create("ScaleTimeline", obj, __jsb_spine_TranslateTimeline_proto, _SE(js_new_spine_ScaleTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ScaleTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ScaleTimeline_proto = cls->getProto(); + __jsb_spine_ScaleTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ShearTimeline_class = nullptr; +se::Object* __jsb_spine_ShearTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ShearTimeline) + +static bool js_new_spine_ShearTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::ShearTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::ShearTimeline *)new spine::ShearTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ShearTimeline, __jsb_spine_ShearTimeline_class, js_delete_spine_ShearTimeline) + +static bool js_delete_spine_ShearTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ShearTimeline) + +bool js_register_spine_ShearTimeline(se::Object* obj) { + auto* cls = se::Class::create("ShearTimeline", obj, __jsb_spine_TranslateTimeline_proto, _SE(js_new_spine_ShearTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ShearTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ShearTimeline_proto = cls->getProto(); + __jsb_spine_ShearTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Skeleton_class = nullptr; +se::Object* __jsb_spine_Skeleton_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skeleton) + +static bool js_new_spine_Skeleton(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Skeleton *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Skeleton *)new spine::Skeleton(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Skeleton, __jsb_spine_Skeleton_class, js_delete_spine_Skeleton) + +static bool js_delete_spine_Skeleton(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skeleton) + +static bool js_spine_Skeleton_updateCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateCache(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_updateCache) + +static bool js_spine_Skeleton_printUpdateCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->printUpdateCache(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_printUpdateCache) + +static bool js_spine_Skeleton_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_updateWorldTransform) + +static bool js_spine_Skeleton_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setToSetupPose) + +static bool js_spine_Skeleton_setBonesToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setBonesToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setBonesToSetupPose) + +static bool js_spine_Skeleton_setSlotsToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setSlotsToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setSlotsToSetupPose) + +static bool js_spine_Skeleton_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Bone *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(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 = (spine::Bone *)(arg1)->findBone((spine::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_spine_Skeleton_findBone) + +static bool js_spine_Skeleton_findBoneIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findBoneIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_findBoneIndex) + +static bool js_spine_Skeleton_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Slot *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(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 = (spine::Slot *)(arg1)->findSlot((spine::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_spine_Skeleton_findSlot) + +static bool js_spine_Skeleton_findSlotIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findSlotIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_findSlotIndex) + +static bool js_spine_Skeleton_setSkinByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSkin((spine::String const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setSkinByName) + +static bool js_spine_Skeleton_getAttachment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String *arg3 = 0 ; + spine::String temp2 ; + spine::String temp3 ; + spine::Attachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *)(arg1)->getAttachment((spine::String const &)*arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Skeleton_getAttachment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + int arg2 ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::Attachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::Attachment *)(arg1)->getAttachment(arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Skeleton_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_spine_Skeleton_getAttachment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_spine_Skeleton_getAttachment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_Skeleton_getAttachment) + +static bool js_spine_Skeleton_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String *arg3 = 0 ; + spine::String temp2 ; + spine::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(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)->setAttachment((spine::String const &)*arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setAttachment) + +static bool js_spine_Skeleton_findIkConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::IkConstraint *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(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 = (spine::IkConstraint *)(arg1)->findIkConstraint((spine::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_spine_Skeleton_findIkConstraint) + +static bool js_spine_Skeleton_findTransformConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::TransformConstraint *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(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 = (spine::TransformConstraint *)(arg1)->findTransformConstraint((spine::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_spine_Skeleton_findTransformConstraint) + +static bool js_spine_Skeleton_findPathConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::PathConstraint *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(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 = (spine::PathConstraint *)(arg1)->findPathConstraint((spine::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_spine_Skeleton_findPathConstraint) + +static bool js_spine_Skeleton_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_update) + +static bool js_spine_Skeleton_getRootBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Bone *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(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)(arg1)->getRootBone(); + + 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_spine_Skeleton_getRootBone) + +static bool js_spine_Skeleton_setPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPosition(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setPosition) + +static bool js_spine_Skeleton_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::SkeletonData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SkeletonData *)spine_Skeleton_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_data_get) + +static bool js_spine_Skeleton_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_Skeleton_bones_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_spine_Skeleton_bones_get) + +static bool js_spine_Skeleton_slots_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Slot * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Slot * > *) &spine_Skeleton_slots_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_spine_Skeleton_slots_get) + +static bool js_spine_Skeleton_drawOrder_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Slot * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Slot * > *) &spine_Skeleton_drawOrder_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_spine_Skeleton_drawOrder_get) + +static bool js_spine_Skeleton_ikConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::IkConstraint * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::IkConstraint * > *) &spine_Skeleton_ikConstraints_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_spine_Skeleton_ikConstraints_get) + +static bool js_spine_Skeleton_transformConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::TransformConstraint * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::TransformConstraint * > *) &spine_Skeleton_transformConstraints_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_spine_Skeleton_transformConstraints_get) + +static bool js_spine_Skeleton_pathConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::PathConstraint * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::PathConstraint * > *) &spine_Skeleton_pathConstraints_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_spine_Skeleton_pathConstraints_get) + +static bool js_spine_Skeleton__updateCache_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Updatable * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Updatable * > *) &spine_Skeleton__updateCache_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_spine_Skeleton__updateCache_get) + +static bool js_spine_Skeleton_skin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_skin_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_skin_set) + +static bool js_spine_Skeleton_skin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Skin *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Skin *)spine_Skeleton_skin_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_spine_Skeleton_skin_get) + +static bool js_spine_Skeleton_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_Skeleton_color_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_spine_Skeleton_color_get) + +static bool js_spine_Skeleton_time_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_time_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_time_set) + +static bool js_spine_Skeleton_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_time_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_time_get) + +static bool js_spine_Skeleton_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_scaleX_set) + +static bool js_spine_Skeleton_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_scaleX_get) + +static bool js_spine_Skeleton_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_scaleY_set) + +static bool js_spine_Skeleton_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_scaleY_get) + +static bool js_spine_Skeleton_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_x_set) + +static bool js_spine_Skeleton_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_x_get) + +static bool js_spine_Skeleton_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_y_set) + +static bool js_spine_Skeleton_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_y_get) + +static bool js_spine_Skeleton_getAttachmentByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *) &spine_Skeleton_getAttachmentByName(arg1,(std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_getAttachmentByName) + +bool js_register_spine_Skeleton(se::Object* obj) { + auto* cls = se::Class::create("Skeleton", obj, nullptr, _SE(js_new_spine_Skeleton)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Skeleton_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_Skeleton_bones_get), nullptr); + cls->defineProperty("slots", _SE(js_spine_Skeleton_slots_get), nullptr); + cls->defineProperty("drawOrder", _SE(js_spine_Skeleton_drawOrder_get), nullptr); + cls->defineProperty("ikConstraints", _SE(js_spine_Skeleton_ikConstraints_get), nullptr); + cls->defineProperty("transformConstraints", _SE(js_spine_Skeleton_transformConstraints_get), nullptr); + cls->defineProperty("pathConstraints", _SE(js_spine_Skeleton_pathConstraints_get), nullptr); + cls->defineProperty("_updateCache", _SE(js_spine_Skeleton__updateCache_get), nullptr); + cls->defineProperty("skin", _SE(js_spine_Skeleton_skin_get), _SE(js_spine_Skeleton_skin_set)); + cls->defineProperty("color", _SE(js_spine_Skeleton_color_get), nullptr); + cls->defineProperty("time", _SE(js_spine_Skeleton_time_get), _SE(js_spine_Skeleton_time_set)); + cls->defineProperty("scaleX", _SE(js_spine_Skeleton_scaleX_get), _SE(js_spine_Skeleton_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_Skeleton_scaleY_get), _SE(js_spine_Skeleton_scaleY_set)); + cls->defineProperty("x", _SE(js_spine_Skeleton_x_get), _SE(js_spine_Skeleton_x_set)); + cls->defineProperty("y", _SE(js_spine_Skeleton_y_get), _SE(js_spine_Skeleton_y_set)); + + cls->defineFunction("updateCache", _SE(js_spine_Skeleton_updateCache)); + cls->defineFunction("printUpdateCache", _SE(js_spine_Skeleton_printUpdateCache)); + cls->defineFunction("updateWorldTransform", _SE(js_spine_Skeleton_updateWorldTransform)); + cls->defineFunction("setToSetupPose", _SE(js_spine_Skeleton_setToSetupPose)); + cls->defineFunction("setBonesToSetupPose", _SE(js_spine_Skeleton_setBonesToSetupPose)); + cls->defineFunction("setSlotsToSetupPose", _SE(js_spine_Skeleton_setSlotsToSetupPose)); + cls->defineFunction("findBone", _SE(js_spine_Skeleton_findBone)); + cls->defineFunction("findBoneIndex", _SE(js_spine_Skeleton_findBoneIndex)); + cls->defineFunction("findSlot", _SE(js_spine_Skeleton_findSlot)); + cls->defineFunction("findSlotIndex", _SE(js_spine_Skeleton_findSlotIndex)); + cls->defineFunction("setSkinByName", _SE(js_spine_Skeleton_setSkinByName)); + cls->defineFunction("getAttachment", _SE(js_spine_Skeleton_getAttachment)); + cls->defineFunction("setAttachment", _SE(js_spine_Skeleton_setAttachment)); + cls->defineFunction("findIkConstraint", _SE(js_spine_Skeleton_findIkConstraint)); + cls->defineFunction("findTransformConstraint", _SE(js_spine_Skeleton_findTransformConstraint)); + cls->defineFunction("findPathConstraint", _SE(js_spine_Skeleton_findPathConstraint)); + cls->defineFunction("update", _SE(js_spine_Skeleton_update)); + cls->defineFunction("getRootBone", _SE(js_spine_Skeleton_getRootBone)); + cls->defineFunction("setPosition", _SE(js_spine_Skeleton_setPosition)); + cls->defineFunction("getAttachmentByName", _SE(js_spine_Skeleton_getAttachmentByName)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skeleton)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skeleton_proto = cls->getProto(); + __jsb_spine_Skeleton_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Slot_class = nullptr; +se::Object* __jsb_spine_Slot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Slot) + +static bool js_spine_Slot_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_setToSetupPose) + +static bool js_spine_Slot_getSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Skeleton *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(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *) &(arg1)->getSkeleton(); + + 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_spine_Slot_getSkeleton) + +static bool js_spine_Slot_hasDarkColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->hasDarkColor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_hasDarkColor) + +static bool js_spine_Slot_getAttachmentState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getAttachmentState(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_getAttachmentState) + +static bool js_spine_Slot_setAttachmentState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachmentState(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_setAttachmentState) + +static bool js_spine_Slot_getAttachmentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getAttachmentTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_getAttachmentTime) + +static bool js_spine_Slot_setAttachmentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachmentTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_setAttachmentTime) + +static bool js_spine_Slot_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::SlotData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SlotData *) &spine_Slot_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Slot_data_get) + +static bool js_spine_Slot_bone_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *) &spine_Slot_bone_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_spine_Slot_bone_get) + +static bool js_spine_Slot_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_Slot_color_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_spine_Slot_color_get) + +static bool js_spine_Slot_darkColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_Slot_darkColor_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_spine_Slot_darkColor_get) + +static bool js_spine_Slot_attachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Attachment *arg2 = (spine::Attachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Slot_attachment_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Slot_attachment_set) + +static bool js_spine_Slot_attachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Attachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Attachment *)spine_Slot_attachment_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_spine_Slot_attachment_get) + +static bool js_spine_Slot_deform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_Slot_deform_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_spine_Slot_deform_get) + +static bool js_new_spine_Slot(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + spine::Slot *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Slot *)new_spine_Slot(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Slot, __jsb_spine_Slot_class, js_delete_spine_Slot) + +static bool js_delete_spine_Slot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Slot) + +bool js_register_spine_Slot(se::Object* obj) { + auto* cls = se::Class::create("Slot", obj, nullptr, _SE(js_new_spine_Slot)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Slot_data_get), nullptr); + cls->defineProperty("bone", _SE(js_spine_Slot_bone_get), nullptr); + cls->defineProperty("color", _SE(js_spine_Slot_color_get), nullptr); + cls->defineProperty("darkColor", _SE(js_spine_Slot_darkColor_get), nullptr); + cls->defineProperty("attachment", _SE(js_spine_Slot_attachment_get), _SE(js_spine_Slot_attachment_set)); + cls->defineProperty("deform", _SE(js_spine_Slot_deform_get), nullptr); + + cls->defineFunction("setToSetupPose", _SE(js_spine_Slot_setToSetupPose)); + cls->defineFunction("getSkeleton", _SE(js_spine_Slot_getSkeleton)); + cls->defineFunction("hasDarkColor", _SE(js_spine_Slot_hasDarkColor)); + cls->defineFunction("getAttachmentState", _SE(js_spine_Slot_getAttachmentState)); + cls->defineFunction("setAttachmentState", _SE(js_spine_Slot_setAttachmentState)); + cls->defineFunction("getAttachmentTime", _SE(js_spine_Slot_getAttachmentTime)); + cls->defineFunction("setAttachmentTime", _SE(js_spine_Slot_setAttachmentTime)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Slot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Slot_proto = cls->getProto(); + __jsb_spine_Slot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Skin_class = nullptr; +se::Object* __jsb_spine_Skin_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin) + +se::Class* __jsb_spine_Skin_AttachmentMap_class = nullptr; +se::Object* __jsb_spine_Skin_AttachmentMap_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap) + +se::Class* __jsb_spine_Skin_AttachmentMap_Entry_class = nullptr; +se::Object* __jsb_spine_Skin_AttachmentMap_Entry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entry) + +static bool js_spine_Skin_AttachmentMap_Entry_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_slotIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skin_AttachmentMap_Entry_slotIndex_set) + +static bool js_spine_Skin_AttachmentMap_Entry_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_slotIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skin_AttachmentMap_Entry_slotIndex_get) + +static bool js_spine_Skin_AttachmentMap_Entry_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skin_AttachmentMap_Entry_name_set) + +static bool js_spine_Skin_AttachmentMap_Entry_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skin_AttachmentMap_Entry_name_get) + +static bool js_spine_Skin_AttachmentMap_Entry_attachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_attachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skin_AttachmentMap_Entry_attachment_set) + +static bool js_spine_Skin_AttachmentMap_Entry_attachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_attachment, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_attachment, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skin_AttachmentMap_Entry_attachment_get) + +static bool js_new_spine_Skin_AttachmentMap_Entry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + size_t arg1 ; + spine::String *arg2 = 0 ; + spine::Attachment *arg3 = (spine::Attachment *) NULL ; + spine::String temp2 ; + spine::Skin::AttachmentMap::Entry *result; + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Skin::AttachmentMap::Entry *)new spine::Skin::AttachmentMap::Entry(arg1,(spine::String const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Skin_AttachmentMap_Entry, __jsb_spine_Skin_AttachmentMap_Entry_class, js_delete_spine_Skin_AttachmentMap_Entry) + +static bool js_delete_spine_Skin_AttachmentMap_Entry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entry) + +template<> +bool sevalue_to_native(const se::Value &from, spine::Skin::AttachmentMap::Entry * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("slotIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_slotIndex), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_name), ctx); + } + + + json->getProperty("attachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_attachment), ctx); + } + + + return ok; +} + + +bool js_register_spine_Skin_AttachmentMap_Entry(se::Object* obj) { + auto* cls = se::Class::create({"Skin", "AttachmentMap", "Entry"}, obj, nullptr, _SE(js_new_spine_Skin_AttachmentMap_Entry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_Skin_AttachmentMap_Entry_slotIndex_get), _SE(js_spine_Skin_AttachmentMap_Entry_slotIndex_set)); + cls->defineProperty("name", _SE(js_spine_Skin_AttachmentMap_Entry_name_get), _SE(js_spine_Skin_AttachmentMap_Entry_name_set)); + cls->defineProperty("attachment", _SE(js_spine_Skin_AttachmentMap_Entry_attachment_get), _SE(js_spine_Skin_AttachmentMap_Entry_attachment_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin_AttachmentMap_Entry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_AttachmentMap_Entry_proto = cls->getProto(); + __jsb_spine_Skin_AttachmentMap_Entry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Skin_AttachmentMap_Entries_class = nullptr; +se::Object* __jsb_spine_Skin_AttachmentMap_Entries_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entries) + +static bool js_spine_Skin_AttachmentMap_Entries_hasNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entries *arg1 = (spine::Skin::AttachmentMap::Entries *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->hasNext(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_Entries_hasNext) + +static bool js_spine_Skin_AttachmentMap_Entries_next(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entries *arg1 = (spine::Skin::AttachmentMap::Entries *) NULL ; + spine::Skin::AttachmentMap::Entry *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(s); + if (nullptr == arg1) return true; + result = (spine::Skin::AttachmentMap::Entry *) &(arg1)->next(); + + 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_spine_Skin_AttachmentMap_Entries_next) + +static bool js_delete_spine_Skin_AttachmentMap_Entries(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entries) + +bool js_register_spine_Skin_AttachmentMap_Entries(se::Object* obj) { + auto* cls = se::Class::create({"Skin", "AttachmentMap", "Entries"}, obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("hasNext", _SE(js_spine_Skin_AttachmentMap_Entries_hasNext)); + cls->defineFunction("next", _SE(js_spine_Skin_AttachmentMap_Entries_next)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin_AttachmentMap_Entries)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_AttachmentMap_Entries_proto = cls->getProto(); + __jsb_spine_Skin_AttachmentMap_Entries_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_spine_Skin_AttachmentMap_put(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap *arg1 = (spine::Skin::AttachmentMap *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::Attachment *arg4 = (spine::Attachment *) NULL ; + spine::String temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->put(arg2,(spine::String const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_put) + +static bool js_spine_Skin_AttachmentMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap *arg1 = (spine::Skin::AttachmentMap *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::Attachment *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(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 = (spine::Attachment *)(arg1)->get(arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_get) + +static bool js_spine_Skin_AttachmentMap_remove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap *arg1 = (spine::Skin::AttachmentMap *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->remove(arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_remove) + +static bool js_delete_spine_Skin_AttachmentMap(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap) + +bool js_register_spine_Skin_AttachmentMap(se::Object* obj) { + auto* cls = se::Class::create({"Skin", "AttachmentMap"}, obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("put", _SE(js_spine_Skin_AttachmentMap_put)); + cls->defineFunction("get", _SE(js_spine_Skin_AttachmentMap_get)); + cls->defineFunction("remove", _SE(js_spine_Skin_AttachmentMap_remove)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin_AttachmentMap)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_AttachmentMap_proto = cls->getProto(); + __jsb_spine_Skin_AttachmentMap_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_new_spine_Skin(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::Skin *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::Skin *)new spine::Skin((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Skin, __jsb_spine_Skin_class, js_delete_spine_Skin) + +static bool js_delete_spine_Skin(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin) + +static bool js_spine_Skin_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::Attachment *arg4 = (spine::Attachment *) NULL ; + spine::String temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachment(arg2,(spine::String const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_setAttachment) + +static bool js_spine_Skin_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::Attachment *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(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 = (spine::Attachment *)(arg1)->getAttachment(arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_getAttachment) + +static bool js_spine_Skin_removeAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->removeAttachment(arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_removeAttachment) + +static bool js_spine_Skin_addSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSkin(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_addSkin) + +static bool js_spine_Skin_copySkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->copySkin(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_copySkin) + +static bool js_spine_Skin_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Skin_name_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_spine_Skin_name_get) + +static bool js_spine_Skin_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_Skin_bones_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_spine_Skin_bones_get) + +static bool js_spine_Skin_constraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Vector< spine::ConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::ConstraintData * > *) &spine_Skin_constraints_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_spine_Skin_constraints_get) + +bool js_register_spine_Skin(se::Object* obj) { + auto* cls = se::Class::create("Skin", obj, nullptr, _SE(js_new_spine_Skin)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_Skin_name_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_Skin_bones_get), nullptr); + cls->defineProperty("constraints", _SE(js_spine_Skin_constraints_get), nullptr); + + cls->defineFunction("setAttachment", _SE(js_spine_Skin_setAttachment)); + cls->defineFunction("getAttachment", _SE(js_spine_Skin_getAttachment)); + cls->defineFunction("removeAttachment", _SE(js_spine_Skin_removeAttachment)); + cls->defineFunction("addSkin", _SE(js_spine_Skin_addSkin)); + cls->defineFunction("copySkin", _SE(js_spine_Skin_copySkin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_proto = cls->getProto(); + __jsb_spine_Skin_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SkeletonBounds_class = nullptr; +se::Object* __jsb_spine_SkeletonBounds_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SkeletonBounds) + +static bool js_new_spine_SkeletonBounds(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::SkeletonBounds *result; + result = (spine::SkeletonBounds *)new spine::SkeletonBounds(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SkeletonBounds, __jsb_spine_SkeletonBounds_class, js_delete_spine_SkeletonBounds) + +static bool js_delete_spine_SkeletonBounds(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SkeletonBounds) + +static bool js_spine_SkeletonBounds_aabbcontainsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->aabbcontainsPoint(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_aabbcontainsPoint) + +static bool js_spine_SkeletonBounds_aabbintersectsSegment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->aabbintersectsSegment(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_aabbintersectsSegment) + +static bool js_spine_SkeletonBounds_aabbIntersectsSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::SkeletonBounds arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->aabbIntersectsSkeleton(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_aabbIntersectsSkeleton) + +static bool js_spine_SkeletonBounds_containsPoint__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::Polygon *arg2 = (spine::Polygon *) NULL ; + float arg3 ; + float arg4 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->containsPoint(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_SkeletonBounds_containsPoint__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + spine::BoundingBoxAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::BoundingBoxAttachment *)(arg1)->containsPoint(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_spine_SkeletonBounds_containsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_spine_SkeletonBounds_containsPoint__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_spine_SkeletonBounds_containsPoint__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_containsPoint) + +static bool js_spine_SkeletonBounds_intersectsSegment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + spine::BoundingBoxAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::BoundingBoxAttachment *)(arg1)->intersectsSegment(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_SkeletonBounds_intersectsSegment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::Polygon *arg2 = (spine::Polygon *) NULL ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->intersectsSegment(arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_SkeletonBounds_intersectsSegment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_SkeletonBounds_intersectsSegment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_spine_SkeletonBounds_intersectsSegment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_intersectsSegment) + +static bool js_spine_SkeletonBounds_getPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::BoundingBoxAttachment *arg2 = (spine::BoundingBoxAttachment *) NULL ; + spine::Polygon *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Polygon *)(arg1)->getPolygon(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_spine_SkeletonBounds_getPolygon) + +static bool js_spine_SkeletonBounds_getWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_getWidth) + +static bool js_spine_SkeletonBounds_getHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_getHeight) + +static bool js_spine_SkeletonBounds_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonBounds_update(arg1,arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_update) + +bool js_register_spine_SkeletonBounds(se::Object* obj) { + auto* cls = se::Class::create("SkeletonBounds", obj, nullptr, _SE(js_new_spine_SkeletonBounds)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("aabbcontainsPoint", _SE(js_spine_SkeletonBounds_aabbcontainsPoint)); + cls->defineFunction("aabbintersectsSegment", _SE(js_spine_SkeletonBounds_aabbintersectsSegment)); + cls->defineFunction("aabbIntersectsSkeleton", _SE(js_spine_SkeletonBounds_aabbIntersectsSkeleton)); + cls->defineFunction("containsPoint", _SE(js_spine_SkeletonBounds_containsPoint)); + cls->defineFunction("intersectsSegment", _SE(js_spine_SkeletonBounds_intersectsSegment)); + cls->defineFunction("getPolygon", _SE(js_spine_SkeletonBounds_getPolygon)); + cls->defineFunction("getWidth", _SE(js_spine_SkeletonBounds_getWidth)); + cls->defineFunction("getHeight", _SE(js_spine_SkeletonBounds_getHeight)); + cls->defineFunction("update", _SE(js_spine_SkeletonBounds_update)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SkeletonBounds)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SkeletonBounds_proto = cls->getProto(); + __jsb_spine_SkeletonBounds_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Polygon_class = nullptr; +se::Object* __jsb_spine_Polygon_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Polygon) + +static bool js_spine_Polygon__count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Polygon *arg1 = (spine::Polygon *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Polygon__count_set) + +static bool js_spine_Polygon__count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Polygon *arg1 = (spine::Polygon *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Polygon__count_get) + +static bool js_delete_spine_Polygon(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Polygon) + +bool js_register_spine_Polygon(se::Object* obj) { + auto* cls = se::Class::create("Polygon", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_count", _SE(js_spine_Polygon__count_get), _SE(js_spine_Polygon__count_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Polygon)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Polygon_proto = cls->getProto(); + __jsb_spine_Polygon_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SkeletonData_class = nullptr; +se::Object* __jsb_spine_SkeletonData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SkeletonData) + +static bool js_new_spine_SkeletonData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::SkeletonData *result; + result = (spine::SkeletonData *)new spine::SkeletonData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SkeletonData, __jsb_spine_SkeletonData_class, js_delete_spine_SkeletonData) + +static bool js_delete_spine_SkeletonData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SkeletonData) + +static bool js_spine_SkeletonData_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::BoneData *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(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 = (spine::BoneData *)(arg1)->findBone((spine::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_spine_SkeletonData_findBone) + +static bool js_spine_SkeletonData_findBoneIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findBoneIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonData_findBoneIndex) + +static bool js_spine_SkeletonData_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::SlotData *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(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 = (spine::SlotData *)(arg1)->findSlot((spine::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_spine_SkeletonData_findSlot) + +static bool js_spine_SkeletonData_findSlotIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findSlotIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonData_findSlotIndex) + +static bool js_spine_SkeletonData_findSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Skin *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(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 = (spine::Skin *)(arg1)->findSkin((spine::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_spine_SkeletonData_findSkin) + +static bool js_spine_SkeletonData_findEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::EventData *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(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 = (spine::EventData *)(arg1)->findEvent((spine::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_spine_SkeletonData_findEvent) + +static bool js_spine_SkeletonData_findAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Animation *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(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 = (spine::Animation *)(arg1)->findAnimation((spine::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_spine_SkeletonData_findAnimation) + +static bool js_spine_SkeletonData_findIkConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::IkConstraintData *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(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 = (spine::IkConstraintData *)(arg1)->findIkConstraint((spine::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_spine_SkeletonData_findIkConstraint) + +static bool js_spine_SkeletonData_findTransformConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::TransformConstraintData *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(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 = (spine::TransformConstraintData *)(arg1)->findTransformConstraint((spine::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_spine_SkeletonData_findTransformConstraint) + +static bool js_spine_SkeletonData_findPathConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::PathConstraintData *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(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 = (spine::PathConstraintData *)(arg1)->findPathConstraint((spine::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_spine_SkeletonData_findPathConstraint) + +static bool js_spine_SkeletonData_findPathConstraintIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findPathConstraintIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonData_findPathConstraintIndex) + +static bool js_spine_SkeletonData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_name_set) + +static bool js_spine_SkeletonData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_name_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_spine_SkeletonData_name_get) + +static bool js_spine_SkeletonData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_SkeletonData_bones_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_spine_SkeletonData_bones_get) + +static bool js_spine_SkeletonData_slots_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::SlotData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::SlotData * > *) &spine_SkeletonData_slots_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_spine_SkeletonData_slots_get) + +static bool js_spine_SkeletonData_skins_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::Skin * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Skin * > *) &spine_SkeletonData_skins_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_spine_SkeletonData_skins_get) + +static bool js_spine_SkeletonData_defaultSkin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_defaultSkin_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_defaultSkin_set) + +static bool js_spine_SkeletonData_defaultSkin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Skin *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Skin *)spine_SkeletonData_defaultSkin_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_spine_SkeletonData_defaultSkin_get) + +static bool js_spine_SkeletonData_events_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::EventData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::EventData * > *) &spine_SkeletonData_events_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_spine_SkeletonData_events_get) + +static bool js_spine_SkeletonData_animations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::Animation * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Animation * > *) &spine_SkeletonData_animations_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_spine_SkeletonData_animations_get) + +static bool js_spine_SkeletonData_ikConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::IkConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::IkConstraintData * > *) &spine_SkeletonData_ikConstraints_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_spine_SkeletonData_ikConstraints_get) + +static bool js_spine_SkeletonData_transformConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::TransformConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::TransformConstraintData * > *) &spine_SkeletonData_transformConstraints_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_spine_SkeletonData_transformConstraints_get) + +static bool js_spine_SkeletonData_pathConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::PathConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::PathConstraintData * > *) &spine_SkeletonData_pathConstraints_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_spine_SkeletonData_pathConstraints_get) + +static bool js_spine_SkeletonData_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_x_set) + +static bool js_spine_SkeletonData_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_x_get) + +static bool js_spine_SkeletonData_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_y_set) + +static bool js_spine_SkeletonData_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_y_get) + +static bool js_spine_SkeletonData_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_width_set) + +static bool js_spine_SkeletonData_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_width_get) + +static bool js_spine_SkeletonData_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_height_set) + +static bool js_spine_SkeletonData_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_height_get) + +static bool js_spine_SkeletonData_version_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_version_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_version_set) + +static bool js_spine_SkeletonData_version_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_version_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_spine_SkeletonData_version_get) + +static bool js_spine_SkeletonData_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_hash_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_hash_set) + +static bool js_spine_SkeletonData_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_hash_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_spine_SkeletonData_hash_get) + +static bool js_spine_SkeletonData_fps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_fps_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_fps_set) + +static bool js_spine_SkeletonData_fps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_fps_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_fps_get) + +static bool js_spine_SkeletonData_imagesPath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_imagesPath_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_imagesPath_set) + +static bool js_spine_SkeletonData_imagesPath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_imagesPath_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_spine_SkeletonData_imagesPath_get) + +static bool js_spine_SkeletonData_audioPath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_audioPath_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_audioPath_set) + +static bool js_spine_SkeletonData_audioPath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_audioPath_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_spine_SkeletonData_audioPath_get) + +bool js_register_spine_SkeletonData(se::Object* obj) { + auto* cls = se::Class::create("SkeletonData", obj, nullptr, _SE(js_new_spine_SkeletonData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_SkeletonData_name_get), _SE(js_spine_SkeletonData_name_set)); + cls->defineProperty("bones", _SE(js_spine_SkeletonData_bones_get), nullptr); + cls->defineProperty("slots", _SE(js_spine_SkeletonData_slots_get), nullptr); + cls->defineProperty("skins", _SE(js_spine_SkeletonData_skins_get), nullptr); + cls->defineProperty("defaultSkin", _SE(js_spine_SkeletonData_defaultSkin_get), _SE(js_spine_SkeletonData_defaultSkin_set)); + cls->defineProperty("events", _SE(js_spine_SkeletonData_events_get), nullptr); + cls->defineProperty("animations", _SE(js_spine_SkeletonData_animations_get), nullptr); + cls->defineProperty("ikConstraints", _SE(js_spine_SkeletonData_ikConstraints_get), nullptr); + cls->defineProperty("transformConstraints", _SE(js_spine_SkeletonData_transformConstraints_get), nullptr); + cls->defineProperty("pathConstraints", _SE(js_spine_SkeletonData_pathConstraints_get), nullptr); + cls->defineProperty("x", _SE(js_spine_SkeletonData_x_get), _SE(js_spine_SkeletonData_x_set)); + cls->defineProperty("y", _SE(js_spine_SkeletonData_y_get), _SE(js_spine_SkeletonData_y_set)); + cls->defineProperty("width", _SE(js_spine_SkeletonData_width_get), _SE(js_spine_SkeletonData_width_set)); + cls->defineProperty("height", _SE(js_spine_SkeletonData_height_get), _SE(js_spine_SkeletonData_height_set)); + cls->defineProperty("version", _SE(js_spine_SkeletonData_version_get), _SE(js_spine_SkeletonData_version_set)); + cls->defineProperty("hash", _SE(js_spine_SkeletonData_hash_get), _SE(js_spine_SkeletonData_hash_set)); + cls->defineProperty("fps", _SE(js_spine_SkeletonData_fps_get), _SE(js_spine_SkeletonData_fps_set)); + cls->defineProperty("imagesPath", _SE(js_spine_SkeletonData_imagesPath_get), _SE(js_spine_SkeletonData_imagesPath_set)); + cls->defineProperty("audioPath", _SE(js_spine_SkeletonData_audioPath_get), _SE(js_spine_SkeletonData_audioPath_set)); + + cls->defineFunction("findBone", _SE(js_spine_SkeletonData_findBone)); + cls->defineFunction("findBoneIndex", _SE(js_spine_SkeletonData_findBoneIndex)); + cls->defineFunction("findSlot", _SE(js_spine_SkeletonData_findSlot)); + cls->defineFunction("findSlotIndex", _SE(js_spine_SkeletonData_findSlotIndex)); + cls->defineFunction("findSkin", _SE(js_spine_SkeletonData_findSkin)); + cls->defineFunction("findEvent", _SE(js_spine_SkeletonData_findEvent)); + cls->defineFunction("findAnimation", _SE(js_spine_SkeletonData_findAnimation)); + cls->defineFunction("findIkConstraint", _SE(js_spine_SkeletonData_findIkConstraint)); + cls->defineFunction("findTransformConstraint", _SE(js_spine_SkeletonData_findTransformConstraint)); + cls->defineFunction("findPathConstraint", _SE(js_spine_SkeletonData_findPathConstraint)); + cls->defineFunction("findPathConstraintIndex", _SE(js_spine_SkeletonData_findPathConstraintIndex)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SkeletonData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SkeletonData_proto = cls->getProto(); + __jsb_spine_SkeletonData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SlotData_class = nullptr; +se::Object* __jsb_spine_SlotData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SlotData) + +static bool js_spine_SlotData_hasDarkColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->hasDarkColor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SlotData_hasDarkColor) + +static bool js_spine_SlotData_setHasDarkColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHasDarkColor(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_SlotData_setHasDarkColor) + +static bool js_spine_SlotData_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_SlotData_index_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SlotData_index_get) + +static bool js_spine_SlotData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SlotData_name_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_spine_SlotData_name_get) + +static bool js_spine_SlotData_boneData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *) &spine_SlotData_boneData_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_spine_SlotData_boneData_get) + +static bool js_spine_SlotData_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_SlotData_color_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_spine_SlotData_color_get) + +static bool js_spine_SlotData_darkColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_SlotData_darkColor_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_spine_SlotData_darkColor_get) + +static bool js_spine_SlotData_attachmentName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SlotData_attachmentName_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SlotData_attachmentName_set) + +static bool js_spine_SlotData_attachmentName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SlotData_attachmentName_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_spine_SlotData_attachmentName_get) + +static bool js_spine_SlotData_blendMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::BlendMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_SlotData_blendMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SlotData_blendMode_set) + +static bool js_spine_SlotData_blendMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::BlendMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BlendMode)spine_SlotData_blendMode_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_spine_SlotData_blendMode_get) + +static bool js_new_spine_SlotData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + int arg1 ; + ccstd::string *arg2 = (ccstd::string *) NULL ; + spine::BoneData *arg3 = (spine::BoneData *) NULL ; + spine::SlotData *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SlotData *)new_spine_SlotData(arg1,(ccstd::string const *)arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SlotData, __jsb_spine_SlotData_class, js_delete_spine_SlotData) + +static bool js_delete_spine_SlotData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SlotData) + +bool js_register_spine_SlotData(se::Object* obj) { + auto* cls = se::Class::create("SlotData", obj, nullptr, _SE(js_new_spine_SlotData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("index", _SE(js_spine_SlotData_index_get), nullptr); + cls->defineProperty("name", _SE(js_spine_SlotData_name_get), nullptr); + cls->defineProperty("boneData", _SE(js_spine_SlotData_boneData_get), nullptr); + cls->defineProperty("color", _SE(js_spine_SlotData_color_get), nullptr); + cls->defineProperty("darkColor", _SE(js_spine_SlotData_darkColor_get), nullptr); + cls->defineProperty("attachmentName", _SE(js_spine_SlotData_attachmentName_get), _SE(js_spine_SlotData_attachmentName_set)); + cls->defineProperty("blendMode", _SE(js_spine_SlotData_blendMode_get), _SE(js_spine_SlotData_blendMode_set)); + + cls->defineFunction("hasDarkColor", _SE(js_spine_SlotData_hasDarkColor)); + cls->defineFunction("setHasDarkColor", _SE(js_spine_SlotData_setHasDarkColor)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SlotData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SlotData_proto = cls->getProto(); + __jsb_spine_SlotData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SkeletonBinary_class = nullptr; +se::Object* __jsb_spine_SkeletonBinary_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SkeletonBinary) + +static bool js_new_spine_SkeletonBinary__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + spine::SkeletonBinary *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SkeletonBinary *)new spine::SkeletonBinary(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_SkeletonBinary__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::SkeletonBinary *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SkeletonBinary *)new spine::SkeletonBinary(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_SkeletonBinary(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_spine_SkeletonBinary__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_spine_SkeletonBinary__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of SkeletonBinary"); + return false; +} +SE_BIND_CTOR(js_new_spine_SkeletonBinary, __jsb_spine_SkeletonBinary_class, js_delete_spine_SkeletonBinary) + +static bool js_delete_spine_SkeletonBinary(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SkeletonBinary) + +static bool js_spine_SkeletonBinary_readSkeletonDataFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::SkeletonData *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(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 = (spine::SkeletonData *)(arg1)->readSkeletonDataFile((spine::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_spine_SkeletonBinary_readSkeletonDataFile) + +static bool js_spine_SkeletonBinary_getError(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + spine::String *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(s); + if (nullptr == arg1) return true; + result = (spine::String *) &(arg1)->getError(); + + 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_spine_SkeletonBinary_getError) + +static bool js_spine_SkeletonBinary_scale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonBinary_scale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonBinary_scale_set) + +static bool js_spine_SkeletonBinary_readSkeletonData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + std::vector< uint8_t > *arg2 = 0 ; + std::vector< uint8_t > temp2 ; + spine::SkeletonData *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(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 = (spine::SkeletonData *)spine_SkeletonBinary_readSkeletonData(arg1,(std::vector< uint8_t > 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_spine_SkeletonBinary_readSkeletonData) + +bool js_register_spine_SkeletonBinary(se::Object* obj) { + auto* cls = se::Class::create("SkeletonBinary", obj, nullptr, _SE(js_new_spine_SkeletonBinary)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("scale", nullptr, _SE(js_spine_SkeletonBinary_scale_set)); + + cls->defineFunction("readSkeletonDataFile", _SE(js_spine_SkeletonBinary_readSkeletonDataFile)); + cls->defineFunction("getError", _SE(js_spine_SkeletonBinary_getError)); + cls->defineFunction("readSkeletonData", _SE(js_spine_SkeletonBinary_readSkeletonData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SkeletonBinary)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SkeletonBinary_proto = cls->getProto(); + __jsb_spine_SkeletonBinary_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AttachmentLoader_class = nullptr; +se::Object* __jsb_spine_AttachmentLoader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AttachmentLoader) + +static bool js_delete_spine_AttachmentLoader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AttachmentLoader) + +static bool js_spine_AttachmentLoader_configureAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Attachment *arg2 = (spine::Attachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->configureAttachment(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_configureAttachment) + +static bool js_spine_AttachmentLoader_newRegionAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String *arg4 = 0 ; + spine::String temp3 ; + spine::String temp4 ; + spine::RegionAttachment *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (spine::RegionAttachment *)spine_AttachmentLoader_newRegionAttachment(arg1,arg2,(spine::String const &)*arg3,(spine::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; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newRegionAttachment) + +static bool js_spine_AttachmentLoader_newMeshAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String *arg4 = 0 ; + spine::String temp3 ; + spine::String temp4 ; + spine::MeshAttachment *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (spine::MeshAttachment *)spine_AttachmentLoader_newMeshAttachment(arg1,arg2,(spine::String const &)*arg3,(spine::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; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newMeshAttachment) + +static bool js_spine_AttachmentLoader_newBoundingBoxAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::BoundingBoxAttachment *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(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 = (spine::BoundingBoxAttachment *)spine_AttachmentLoader_newBoundingBoxAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newBoundingBoxAttachment) + +static bool js_spine_AttachmentLoader_newPathAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::PathAttachment *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(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 = (spine::PathAttachment *)spine_AttachmentLoader_newPathAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newPathAttachment) + +static bool js_spine_AttachmentLoader_newPointAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::PointAttachment *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(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 = (spine::PointAttachment *)spine_AttachmentLoader_newPointAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newPointAttachment) + +static bool js_spine_AttachmentLoader_newClippingAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::ClippingAttachment *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(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 = (spine::ClippingAttachment *)spine_AttachmentLoader_newClippingAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newClippingAttachment) + +bool js_register_spine_AttachmentLoader(se::Object* obj) { + auto* cls = se::Class::create("AttachmentLoader", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("configureAttachment", _SE(js_spine_AttachmentLoader_configureAttachment)); + cls->defineFunction("newRegionAttachment", _SE(js_spine_AttachmentLoader_newRegionAttachment)); + cls->defineFunction("newMeshAttachment", _SE(js_spine_AttachmentLoader_newMeshAttachment)); + cls->defineFunction("newBoundingBoxAttachment", _SE(js_spine_AttachmentLoader_newBoundingBoxAttachment)); + cls->defineFunction("newPathAttachment", _SE(js_spine_AttachmentLoader_newPathAttachment)); + cls->defineFunction("newPointAttachment", _SE(js_spine_AttachmentLoader_newPointAttachment)); + cls->defineFunction("newClippingAttachment", _SE(js_spine_AttachmentLoader_newClippingAttachment)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AttachmentLoader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AttachmentLoader_proto = cls->getProto(); + __jsb_spine_AttachmentLoader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AtlasPage_class = nullptr; +se::Object* __jsb_spine_AtlasPage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AtlasPage) + +static bool js_spine_TextureAtlasPage_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_name_set) + +static bool js_spine_TextureAtlasPage_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_name_get) + +static bool js_spine_TextureAtlasPage_texturePath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texturePath, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_texturePath_set) + +static bool js_spine_TextureAtlasPage_texturePath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texturePath, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texturePath, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_texturePath_get) + +static bool js_spine_TextureAtlasPage_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_format_set) + +static bool js_spine_TextureAtlasPage_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_format_get) + +static bool js_spine_TextureAtlasPage_minFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_minFilter_set) + +static bool js_spine_TextureAtlasPage_minFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_minFilter_get) + +static bool js_spine_TextureAtlasPage_magFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->magFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_magFilter_set) + +static bool js_spine_TextureAtlasPage_magFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->magFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->magFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_magFilter_get) + +static bool js_spine_TextureAtlasPage_uWrap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uWrap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_uWrap_set) + +static bool js_spine_TextureAtlasPage_uWrap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uWrap, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uWrap, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_uWrap_get) + +static bool js_spine_TextureAtlasPage_vWrap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vWrap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_vWrap_set) + +static bool js_spine_TextureAtlasPage_vWrap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vWrap, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vWrap, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_vWrap_get) + +static bool js_spine_TextureAtlasPage_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_width_set) + +static bool js_spine_TextureAtlasPage_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_width_get) + +static bool js_spine_TextureAtlasPage_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_height_set) + +static bool js_spine_TextureAtlasPage_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_height_get) + +static bool js_new_spine_AtlasPage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::AtlasPage *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::AtlasPage *)new spine::AtlasPage((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AtlasPage, __jsb_spine_AtlasPage_class, js_delete_spine_AtlasPage) + +static bool js_delete_spine_AtlasPage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AtlasPage) + +bool js_register_spine_AtlasPage(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlasPage", obj, nullptr, _SE(js_new_spine_AtlasPage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_TextureAtlasPage_name_get), _SE(js_spine_TextureAtlasPage_name_set)); + cls->defineProperty("texturePath", _SE(js_spine_TextureAtlasPage_texturePath_get), _SE(js_spine_TextureAtlasPage_texturePath_set)); + cls->defineProperty("format", _SE(js_spine_TextureAtlasPage_format_get), _SE(js_spine_TextureAtlasPage_format_set)); + cls->defineProperty("minFilter", _SE(js_spine_TextureAtlasPage_minFilter_get), _SE(js_spine_TextureAtlasPage_minFilter_set)); + cls->defineProperty("magFilter", _SE(js_spine_TextureAtlasPage_magFilter_get), _SE(js_spine_TextureAtlasPage_magFilter_set)); + cls->defineProperty("uWrap", _SE(js_spine_TextureAtlasPage_uWrap_get), _SE(js_spine_TextureAtlasPage_uWrap_set)); + cls->defineProperty("vWrap", _SE(js_spine_TextureAtlasPage_vWrap_get), _SE(js_spine_TextureAtlasPage_vWrap_set)); + cls->defineProperty("width", _SE(js_spine_TextureAtlasPage_width_get), _SE(js_spine_TextureAtlasPage_width_set)); + cls->defineProperty("height", _SE(js_spine_TextureAtlasPage_height_get), _SE(js_spine_TextureAtlasPage_height_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AtlasPage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AtlasPage_proto = cls->getProto(); + __jsb_spine_AtlasPage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AtlasRegion_class = nullptr; +se::Object* __jsb_spine_AtlasRegion_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AtlasRegion) + +static bool js_spine_TextureAtlasRegion_page_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->page, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_page_set) + +static bool js_spine_TextureAtlasRegion_page_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->page, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->page, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_page_get) + +static bool js_spine_TextureAtlasRegion_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_name_set) + +static bool js_spine_TextureAtlasRegion_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_name_get) + +static bool js_spine_TextureAtlasRegion_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_x_set) + +static bool js_spine_TextureAtlasRegion_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_x_get) + +static bool js_spine_TextureAtlasRegion_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_y_set) + +static bool js_spine_TextureAtlasRegion_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_y_get) + +static bool js_spine_TextureAtlasRegion_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_width_set) + +static bool js_spine_TextureAtlasRegion_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_width_get) + +static bool js_spine_TextureAtlasRegion_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_height_set) + +static bool js_spine_TextureAtlasRegion_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_height_get) + +static bool js_spine_TextureAtlasRegion_u_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->u, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_u_set) + +static bool js_spine_TextureAtlasRegion_u_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->u, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_u_get) + +static bool js_spine_TextureAtlasRegion_v_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_v_set) + +static bool js_spine_TextureAtlasRegion_v_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_v_get) + +static bool js_spine_TextureAtlasRegion_u2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->u2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_u2_set) + +static bool js_spine_TextureAtlasRegion_u2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->u2, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_u2_get) + +static bool js_spine_TextureAtlasRegion_v2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_v2_set) + +static bool js_spine_TextureAtlasRegion_v2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v2, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_v2_get) + +static bool js_spine_TextureAtlasRegion_offsetX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offsetX, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_offsetX_set) + +static bool js_spine_TextureAtlasRegion_offsetX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offsetX, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_offsetX_get) + +static bool js_spine_TextureAtlasRegion_offsetY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offsetY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_offsetY_set) + +static bool js_spine_TextureAtlasRegion_offsetY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offsetY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_offsetY_get) + +static bool js_spine_TextureAtlasRegion_originalWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->originalWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_originalWidth_set) + +static bool js_spine_TextureAtlasRegion_originalWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->originalWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_originalWidth_get) + +static bool js_spine_TextureAtlasRegion_originalHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->originalHeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_originalHeight_set) + +static bool js_spine_TextureAtlasRegion_originalHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->originalHeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_originalHeight_get) + +static bool js_spine_TextureAtlasRegion_index_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->index, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_index_set) + +static bool js_spine_TextureAtlasRegion_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->index, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_index_get) + +static bool js_spine_TextureAtlasRegion_rotate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rotate); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_rotate_set) + +static bool js_spine_TextureAtlasRegion_rotate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rotate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_rotate_get) + +static bool js_spine_TextureAtlasRegion_degrees_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->degrees, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_degrees_set) + +static bool js_spine_TextureAtlasRegion_degrees_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->degrees, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_degrees_get) + +static bool js_spine_TextureAtlasRegion_splits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->splits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_splits_set) + +static bool js_spine_TextureAtlasRegion_splits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->splits, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->splits, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_splits_get) + +static bool js_spine_TextureAtlasRegion_pads_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pads, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_pads_set) + +static bool js_spine_TextureAtlasRegion_pads_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pads, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pads, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_pads_get) + +static bool js_new_spine_AtlasRegion(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::AtlasRegion *result; + result = (spine::AtlasRegion *)new spine::AtlasRegion(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AtlasRegion, __jsb_spine_AtlasRegion_class, js_delete_spine_AtlasRegion) + +static bool js_delete_spine_AtlasRegion(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AtlasRegion) + +bool js_register_spine_AtlasRegion(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlasRegion", obj, nullptr, _SE(js_new_spine_AtlasRegion)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("page", _SE(js_spine_TextureAtlasRegion_page_get), _SE(js_spine_TextureAtlasRegion_page_set)); + cls->defineProperty("name", _SE(js_spine_TextureAtlasRegion_name_get), _SE(js_spine_TextureAtlasRegion_name_set)); + cls->defineProperty("x", _SE(js_spine_TextureAtlasRegion_x_get), _SE(js_spine_TextureAtlasRegion_x_set)); + cls->defineProperty("y", _SE(js_spine_TextureAtlasRegion_y_get), _SE(js_spine_TextureAtlasRegion_y_set)); + cls->defineProperty("width", _SE(js_spine_TextureAtlasRegion_width_get), _SE(js_spine_TextureAtlasRegion_width_set)); + cls->defineProperty("height", _SE(js_spine_TextureAtlasRegion_height_get), _SE(js_spine_TextureAtlasRegion_height_set)); + cls->defineProperty("u", _SE(js_spine_TextureAtlasRegion_u_get), _SE(js_spine_TextureAtlasRegion_u_set)); + cls->defineProperty("v", _SE(js_spine_TextureAtlasRegion_v_get), _SE(js_spine_TextureAtlasRegion_v_set)); + cls->defineProperty("u2", _SE(js_spine_TextureAtlasRegion_u2_get), _SE(js_spine_TextureAtlasRegion_u2_set)); + cls->defineProperty("v2", _SE(js_spine_TextureAtlasRegion_v2_get), _SE(js_spine_TextureAtlasRegion_v2_set)); + cls->defineProperty("offsetX", _SE(js_spine_TextureAtlasRegion_offsetX_get), _SE(js_spine_TextureAtlasRegion_offsetX_set)); + cls->defineProperty("offsetY", _SE(js_spine_TextureAtlasRegion_offsetY_get), _SE(js_spine_TextureAtlasRegion_offsetY_set)); + cls->defineProperty("originalWidth", _SE(js_spine_TextureAtlasRegion_originalWidth_get), _SE(js_spine_TextureAtlasRegion_originalWidth_set)); + cls->defineProperty("originalHeight", _SE(js_spine_TextureAtlasRegion_originalHeight_get), _SE(js_spine_TextureAtlasRegion_originalHeight_set)); + cls->defineProperty("index", _SE(js_spine_TextureAtlasRegion_index_get), _SE(js_spine_TextureAtlasRegion_index_set)); + cls->defineProperty("rotate", _SE(js_spine_TextureAtlasRegion_rotate_get), _SE(js_spine_TextureAtlasRegion_rotate_set)); + cls->defineProperty("degrees", _SE(js_spine_TextureAtlasRegion_degrees_get), _SE(js_spine_TextureAtlasRegion_degrees_set)); + cls->defineProperty("splits", _SE(js_spine_TextureAtlasRegion_splits_get), _SE(js_spine_TextureAtlasRegion_splits_set)); + cls->defineProperty("pads", _SE(js_spine_TextureAtlasRegion_pads_get), _SE(js_spine_TextureAtlasRegion_pads_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AtlasRegion)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AtlasRegion_proto = cls->getProto(); + __jsb_spine_AtlasRegion_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Atlas_class = nullptr; +se::Object* __jsb_spine_Atlas_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Atlas) + +static bool js_new_spine_Atlas__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::String *arg1 = 0 ; + spine::TextureLoader *arg2 = (spine::TextureLoader *) NULL ; + bool arg3 ; + spine::String temp1 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((spine::String const &)*arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::String *arg1 = 0 ; + spine::TextureLoader *arg2 = (spine::TextureLoader *) NULL ; + spine::String temp1 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((spine::String const &)*arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + char *arg1 = (char *) NULL ; + int arg2 ; + char *arg3 = (char *) NULL ; + spine::TextureLoader *arg4 = (spine::TextureLoader *) NULL ; + bool arg5 ; + ccstd::string temp1 ; + ccstd::string temp3 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = (char *) temp1.c_str(); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((char const *)arg1,arg2,(char const *)arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + char *arg1 = (char *) NULL ; + int arg2 ; + char *arg3 = (char *) NULL ; + spine::TextureLoader *arg4 = (spine::TextureLoader *) NULL ; + ccstd::string temp1 ; + ccstd::string temp3 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = (char *) temp1.c_str(); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((char const *)arg1,arg2,(char const *)arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_spine_Atlas__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_spine_Atlas__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_spine_Atlas__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_spine_Atlas__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of TextureAtlas"); + return false; +} +SE_BIND_CTOR(js_new_spine_Atlas, __jsb_spine_Atlas_class, js_delete_spine_Atlas) + +static bool js_delete_spine_Atlas(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Atlas) + +static bool js_spine_TextureAtlas_flipV(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->flipV(); + + + return true; +} +SE_BIND_FUNC(js_spine_TextureAtlas_flipV) + +static bool js_spine_TextureAtlas_findRegion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::AtlasRegion *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(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 = (spine::AtlasRegion *)(arg1)->findRegion((spine::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_spine_TextureAtlas_findRegion) + +static bool js_spine_TextureAtlas_getPages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + spine::Vector< spine::AtlasPage * > *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(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::AtlasPage * > *) &(arg1)->getPages(); + + 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_spine_TextureAtlas_getPages) + +bool js_register_spine_Atlas(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlas", obj, nullptr, _SE(js_new_spine_Atlas)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("flipV", _SE(js_spine_TextureAtlas_flipV)); + cls->defineFunction("findRegion", _SE(js_spine_TextureAtlas_findRegion)); + cls->defineFunction("getPages", _SE(js_spine_TextureAtlas_getPages)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Atlas)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Atlas_proto = cls->getProto(); + __jsb_spine_Atlas_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TextureLoader_class = nullptr; +se::Object* __jsb_spine_TextureLoader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TextureLoader) + +static bool js_delete_spine_TextureLoader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TextureLoader) + +static bool js_spine_TextureLoader_unload(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TextureLoader *arg1 = (spine::TextureLoader *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->unload(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_TextureLoader_unload) + +static bool js_spine_TextureLoader_load(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TextureLoader *arg1 = (spine::TextureLoader *) NULL ; + spine::AtlasPage *arg2 = (spine::AtlasPage *) NULL ; + spine::String *arg3 = 0 ; + spine::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(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; + + spine_TextureLoader_load(arg1,arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_TextureLoader_load) + +bool js_register_spine_TextureLoader(se::Object* obj) { + auto* cls = se::Class::create("TextureLoader", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("unload", _SE(js_spine_TextureLoader_unload)); + cls->defineFunction("load", _SE(js_spine_TextureLoader_load)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TextureLoader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TextureLoader_proto = cls->getProto(); + __jsb_spine_TextureLoader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TransformConstraint_class = nullptr; +se::Object* __jsb_spine_TransformConstraint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TransformConstraint) + +static bool js_spine_TransformConstraint_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->apply(); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraint_apply) + +static bool js_spine_TransformConstraint_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraint_update) + +static bool js_spine_TransformConstraint_getOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraint_getOrder) + +static bool js_spine_TransformConstraint_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::TransformConstraintData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TransformConstraintData *) &spine_TransformConstraint_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_data_get) + +static bool js_spine_TransformConstraint_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_TransformConstraint_bones_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_spine_TransformConstraint_bones_get) + +static bool js_spine_TransformConstraint_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_target_set) + +static bool js_spine_TransformConstraint_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)spine_TransformConstraint_target_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_spine_TransformConstraint_target_get) + +static bool js_spine_TransformConstraint_rotateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_rotateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_rotateMix_set) + +static bool js_spine_TransformConstraint_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_rotateMix_get) + +static bool js_spine_TransformConstraint_translateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_translateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_translateMix_set) + +static bool js_spine_TransformConstraint_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_translateMix_get) + +static bool js_spine_TransformConstraint_scaleMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_scaleMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_scaleMix_set) + +static bool js_spine_TransformConstraint_scaleMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_scaleMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_scaleMix_get) + +static bool js_spine_TransformConstraint_shearMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_shearMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_shearMix_set) + +static bool js_spine_TransformConstraint_shearMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_shearMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_shearMix_get) + +static bool js_spine_TransformConstraint_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_active_set) + +static bool js_spine_TransformConstraint_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TransformConstraint_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_active_get) + +static bool js_new_spine_TransformConstraint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::TransformConstraint *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TransformConstraint *)new_spine_TransformConstraint(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TransformConstraint, __jsb_spine_TransformConstraint_class, js_delete_spine_TransformConstraint) + +static bool js_delete_spine_TransformConstraint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TransformConstraint) + +bool js_register_spine_TransformConstraint(se::Object* obj) { + auto* cls = se::Class::create("TransformConstraint", obj, nullptr, _SE(js_new_spine_TransformConstraint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_TransformConstraint_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_TransformConstraint_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_TransformConstraint_target_get), _SE(js_spine_TransformConstraint_target_set)); + cls->defineProperty("rotateMix", _SE(js_spine_TransformConstraint_rotateMix_get), _SE(js_spine_TransformConstraint_rotateMix_set)); + cls->defineProperty("translateMix", _SE(js_spine_TransformConstraint_translateMix_get), _SE(js_spine_TransformConstraint_translateMix_set)); + cls->defineProperty("scaleMix", _SE(js_spine_TransformConstraint_scaleMix_get), _SE(js_spine_TransformConstraint_scaleMix_set)); + cls->defineProperty("shearMix", _SE(js_spine_TransformConstraint_shearMix_get), _SE(js_spine_TransformConstraint_shearMix_set)); + cls->defineProperty("active", _SE(js_spine_TransformConstraint_active_get), _SE(js_spine_TransformConstraint_active_set)); + + cls->defineFunction("apply", _SE(js_spine_TransformConstraint_apply)); + cls->defineFunction("update", _SE(js_spine_TransformConstraint_update)); + cls->defineFunction("getOrder", _SE(js_spine_TransformConstraint_getOrder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TransformConstraint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TransformConstraint_proto = cls->getProto(); + __jsb_spine_TransformConstraint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TransformConstraintData_class = nullptr; +se::Object* __jsb_spine_TransformConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TransformConstraintData) + +static bool js_new_spine_TransformConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::TransformConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::TransformConstraintData *)new spine::TransformConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TransformConstraintData, __jsb_spine_TransformConstraintData_class, js_delete_spine_TransformConstraintData) + +static bool js_spine_TransformConstraintData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_TransformConstraintData_bones_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_spine_TransformConstraintData_bones_get) + +static bool js_spine_TransformConstraintData_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *)spine_TransformConstraintData_target_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_spine_TransformConstraintData_target_get) + +static bool js_spine_TransformConstraintData_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_rotateMix_get) + +static bool js_spine_TransformConstraintData_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_translateMix_get) + +static bool js_spine_TransformConstraintData_scaleMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_scaleMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_scaleMix_get) + +static bool js_spine_TransformConstraintData_shearMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_shearMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_shearMix_get) + +static bool js_spine_TransformConstraintData_offsetRotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetRotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetRotation_get) + +static bool js_spine_TransformConstraintData_offsetX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetX_get) + +static bool js_spine_TransformConstraintData_offsetY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetY_get) + +static bool js_spine_TransformConstraintData_offsetScaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetScaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetScaleX_get) + +static bool js_spine_TransformConstraintData_offsetScaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetScaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetScaleY_get) + +static bool js_spine_TransformConstraintData_offsetShearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetShearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetShearY_get) + +static bool js_spine_TransformConstraintData_relative_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TransformConstraintData_relative_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_relative_get) + +static bool js_spine_TransformConstraintData_local_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TransformConstraintData_local_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_local_get) + +static bool js_delete_spine_TransformConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TransformConstraintData) + +bool js_register_spine_TransformConstraintData(se::Object* obj) { + auto* cls = se::Class::create("TransformConstraintData", obj, __jsb_spine_ConstraintData_proto, _SE(js_new_spine_TransformConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bones", _SE(js_spine_TransformConstraintData_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_TransformConstraintData_target_get), nullptr); + cls->defineProperty("rotateMix", _SE(js_spine_TransformConstraintData_rotateMix_get), nullptr); + cls->defineProperty("translateMix", _SE(js_spine_TransformConstraintData_translateMix_get), nullptr); + cls->defineProperty("scaleMix", _SE(js_spine_TransformConstraintData_scaleMix_get), nullptr); + cls->defineProperty("shearMix", _SE(js_spine_TransformConstraintData_shearMix_get), nullptr); + cls->defineProperty("offsetRotation", _SE(js_spine_TransformConstraintData_offsetRotation_get), nullptr); + cls->defineProperty("offsetX", _SE(js_spine_TransformConstraintData_offsetX_get), nullptr); + cls->defineProperty("offsetY", _SE(js_spine_TransformConstraintData_offsetY_get), nullptr); + cls->defineProperty("offsetScaleX", _SE(js_spine_TransformConstraintData_offsetScaleX_get), nullptr); + cls->defineProperty("offsetScaleY", _SE(js_spine_TransformConstraintData_offsetScaleY_get), nullptr); + cls->defineProperty("offsetShearY", _SE(js_spine_TransformConstraintData_offsetShearY_get), nullptr); + cls->defineProperty("relative", _SE(js_spine_TransformConstraintData_relative_get), nullptr); + cls->defineProperty("local", _SE(js_spine_TransformConstraintData_local_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TransformConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TransformConstraintData_proto = cls->getProto(); + __jsb_spine_TransformConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TransformConstraintTimeline_class = nullptr; +se::Object* __jsb_spine_TransformConstraintTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TransformConstraintTimeline) + +static bool js_new_spine_TransformConstraintTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::TransformConstraintTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TransformConstraintTimeline *)new spine::TransformConstraintTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TransformConstraintTimeline, __jsb_spine_TransformConstraintTimeline_class, js_delete_spine_TransformConstraintTimeline) + +static bool js_spine_TransformConstraintTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraintTimeline *arg1 = (spine::TransformConstraintTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraintTimeline_setFrame) + +static bool js_delete_spine_TransformConstraintTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TransformConstraintTimeline) + +bool js_register_spine_TransformConstraintTimeline(se::Object* obj) { + auto* cls = se::Class::create("TransformConstraintTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_TransformConstraintTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_TransformConstraintTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TransformConstraintTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TransformConstraintTimeline_proto = cls->getProto(); + __jsb_spine_TransformConstraintTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_VertexEffect_class = nullptr; +se::Object* __jsb_spine_VertexEffect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_VertexEffect) + +static bool js_spine_VertexEffect_end(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexEffect *arg1 = (spine::VertexEffect *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->end(); + + + return true; +} +SE_BIND_FUNC(js_spine_VertexEffect_end) + +static bool js_spine_VertexEffect_begin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexEffect *arg1 = (spine::VertexEffect *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_VertexEffect_begin(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_VertexEffect_begin) + +static bool js_delete_spine_VertexEffect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_VertexEffect) + +bool js_register_spine_VertexEffect(se::Object* obj) { + auto* cls = se::Class::create("VertexEffect", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("end", _SE(js_spine_VertexEffect_end)); + cls->defineFunction("begin", _SE(js_spine_VertexEffect_begin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_VertexEffect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_VertexEffect_proto = cls->getProto(); + __jsb_spine_VertexEffect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_JitterVertexEffect_class = nullptr; +se::Object* __jsb_spine_JitterVertexEffect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_JitterVertexEffect) + +static bool js_new_spine_JitterVertexEffect(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + float arg2 ; + spine::JitterVertexEffect *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::JitterVertexEffect *)new spine::JitterVertexEffect(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_JitterVertexEffect, __jsb_spine_JitterVertexEffect_class, js_delete_spine_JitterVertexEffect) + +static bool js_spine_JitterEffect_jitterX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_JitterVertexEffect_jitterX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_JitterEffect_jitterX_set) + +static bool js_spine_JitterEffect_jitterX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_JitterVertexEffect_jitterX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_JitterEffect_jitterX_get) + +static bool js_spine_JitterEffect_jitterY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_JitterVertexEffect_jitterY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_JitterEffect_jitterY_set) + +static bool js_spine_JitterEffect_jitterY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_JitterVertexEffect_jitterY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_JitterEffect_jitterY_get) + +static bool js_delete_spine_JitterVertexEffect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_JitterVertexEffect) + +bool js_register_spine_JitterVertexEffect(se::Object* obj) { + auto* cls = se::Class::create("JitterEffect", obj, __jsb_spine_VertexEffect_proto, _SE(js_new_spine_JitterVertexEffect)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("jitterX", _SE(js_spine_JitterEffect_jitterX_get), _SE(js_spine_JitterEffect_jitterX_set)); + cls->defineProperty("jitterY", _SE(js_spine_JitterEffect_jitterY_get), _SE(js_spine_JitterEffect_jitterY_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_JitterVertexEffect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_JitterVertexEffect_proto = cls->getProto(); + __jsb_spine_JitterVertexEffect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SwirlVertexEffect_class = nullptr; +se::Object* __jsb_spine_SwirlVertexEffect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SwirlVertexEffect) + +static bool js_spine_SwirlEffect_setWorldX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setWorldX(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_setWorldX) + +static bool js_spine_SwirlEffect_getWorldX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_getWorldX) + +static bool js_spine_SwirlEffect_setWorldY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setWorldY(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_setWorldY) + +static bool js_spine_SwirlEffect_getWorldY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_getWorldY) + +static bool js_spine_SwirlEffect_centerX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_centerX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_centerX_set) + +static bool js_spine_SwirlEffect_centerX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_centerX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_centerX_get) + +static bool js_spine_SwirlEffect_centerY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_centerY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_centerY_set) + +static bool js_spine_SwirlEffect_centerY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_centerY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_centerY_get) + +static bool js_spine_SwirlEffect_radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_radius_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_radius_set) + +static bool js_spine_SwirlEffect_radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_radius_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_radius_get) + +static bool js_spine_SwirlEffect_angle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_angle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_angle_set) + +static bool js_spine_SwirlEffect_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_angle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_angle_get) + +static bool js_new_spine_SwirlVertexEffect(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + spine::Interpolation *arg2 = (spine::Interpolation *) NULL ; + spine::SwirlVertexEffect *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SwirlVertexEffect *)new_spine_SwirlVertexEffect(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SwirlVertexEffect, __jsb_spine_SwirlVertexEffect_class, js_delete_spine_SwirlVertexEffect) + +static bool js_delete_spine_SwirlVertexEffect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SwirlVertexEffect) + +bool js_register_spine_SwirlVertexEffect(se::Object* obj) { + auto* cls = se::Class::create("SwirlEffect", obj, __jsb_spine_VertexEffect_proto, _SE(js_new_spine_SwirlVertexEffect)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("centerX", _SE(js_spine_SwirlEffect_centerX_get), _SE(js_spine_SwirlEffect_centerX_set)); + cls->defineProperty("centerY", _SE(js_spine_SwirlEffect_centerY_get), _SE(js_spine_SwirlEffect_centerY_set)); + cls->defineProperty("radius", _SE(js_spine_SwirlEffect_radius_get), _SE(js_spine_SwirlEffect_radius_set)); + cls->defineProperty("angle", _SE(js_spine_SwirlEffect_angle_get), _SE(js_spine_SwirlEffect_angle_set)); + + cls->defineFunction("setWorldX", _SE(js_spine_SwirlEffect_setWorldX)); + cls->defineFunction("getWorldX", _SE(js_spine_SwirlEffect_getWorldX)); + cls->defineFunction("setWorldY", _SE(js_spine_SwirlEffect_setWorldY)); + cls->defineFunction("getWorldY", _SE(js_spine_SwirlEffect_getWorldY)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SwirlVertexEffect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SwirlVertexEffect_proto = cls->getProto(); + __jsb_spine_SwirlVertexEffect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_VertexEffectDelegate_class = nullptr; +se::Object* __jsb_cc_VertexEffectDelegate_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_VertexEffectDelegate) + +static bool js_new_cc_VertexEffectDelegate(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::VertexEffectDelegate *result; + result = (cc::VertexEffectDelegate *)new cc::VertexEffectDelegate(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_VertexEffectDelegate, __jsb_cc_VertexEffectDelegate_class, js_delete_cc_VertexEffectDelegate) + +static bool js_delete_cc_VertexEffectDelegate(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_VertexEffectDelegate) + +static bool js_cc_VertexEffectDelegate_initJitter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + float arg2 ; + float arg3 ; + spine::JitterVertexEffect *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(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 = (spine::JitterVertexEffect *)(arg1)->initJitter(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_VertexEffectDelegate_initJitter) + +static bool js_cc_VertexEffectDelegate_initSwirlWithPow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + float arg2 ; + int arg3 ; + spine::SwirlVertexEffect *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(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 = (spine::SwirlVertexEffect *)(arg1)->initSwirlWithPow(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_VertexEffectDelegate_initSwirlWithPow) + +static bool js_cc_VertexEffectDelegate_initSwirlWithPowOut(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + float arg2 ; + int arg3 ; + spine::SwirlVertexEffect *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(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 = (spine::SwirlVertexEffect *)(arg1)->initSwirlWithPowOut(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_VertexEffectDelegate_initSwirlWithPowOut) + +static bool js_cc_VertexEffectDelegate_getVertexEffect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + spine::VertexEffect *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(s); + if (nullptr == arg1) return true; + result = (spine::VertexEffect *)(arg1)->getVertexEffect(); + + 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_VertexEffectDelegate_getVertexEffect) + +static bool js_cc_VertexEffectDelegate_getJitterVertexEffect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + spine::JitterVertexEffect *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(s); + if (nullptr == arg1) return true; + result = (spine::JitterVertexEffect *)(arg1)->getJitterVertexEffect(); + + 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_VertexEffectDelegate_getJitterVertexEffect) + +static bool js_cc_VertexEffectDelegate_getSwirlVertexEffect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + spine::SwirlVertexEffect *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(s); + if (nullptr == arg1) return true; + result = (spine::SwirlVertexEffect *)(arg1)->getSwirlVertexEffect(); + + 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_VertexEffectDelegate_getSwirlVertexEffect) + +static bool js_cc_VertexEffectDelegate_getEffectType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::VertexEffectDelegate const *)arg1)->getEffectType(); + + 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_VertexEffectDelegate_getEffectType) + +static bool js_cc_VertexEffectDelegate_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_cc_VertexEffectDelegate_clear) + +bool js_register_cc_VertexEffectDelegate(se::Object* obj) { + auto* cls = se::Class::create("VertexEffectDelegate", obj, nullptr, _SE(js_new_cc_VertexEffectDelegate)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initJitter", _SE(js_cc_VertexEffectDelegate_initJitter)); + cls->defineFunction("initSwirlWithPow", _SE(js_cc_VertexEffectDelegate_initSwirlWithPow)); + cls->defineFunction("initSwirlWithPowOut", _SE(js_cc_VertexEffectDelegate_initSwirlWithPowOut)); + cls->defineFunction("getVertexEffect", _SE(js_cc_VertexEffectDelegate_getVertexEffect)); + cls->defineFunction("getJitterVertexEffect", _SE(js_cc_VertexEffectDelegate_getJitterVertexEffect)); + cls->defineFunction("getSwirlVertexEffect", _SE(js_cc_VertexEffectDelegate_getSwirlVertexEffect)); + cls->defineFunction("getEffectType", _SE(js_cc_VertexEffectDelegate_getEffectType)); + cls->defineFunction("clear", _SE(js_cc_VertexEffectDelegate_clear)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_VertexEffectDelegate)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_VertexEffectDelegate_proto = cls->getProto(); + __jsb_cc_VertexEffectDelegate_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonRenderer_class = nullptr; +se::Object* __jsb_cc_SkeletonRenderer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonRenderer) + +static bool js_cc_SkeletonRenderer_create_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)cc::SkeletonRenderer::createWithFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonRenderer_create_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonRenderer *)cc::SkeletonRenderer::createWithFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonRenderer_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonRenderer_create_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonRenderer_create_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_create_static) + +static bool js_cc_SkeletonRenderer_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_update) + +static bool js_cc_SkeletonRenderer_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_render) + +static bool js_cc_SkeletonRenderer_getBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::Rect result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonRenderer const *)arg1)->getBoundingBox(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getBoundingBox) + +static bool js_cc_SkeletonRenderer_getSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *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(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *)((cc::SkeletonRenderer const *)arg1)->getSkeleton(); + + 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_SkeletonRenderer_getSkeleton) + +static bool js_cc_SkeletonRenderer_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setTimeScale) + +static bool js_cc_SkeletonRenderer_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::SkeletonRenderer const *)arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getTimeScale) + +static bool js_cc_SkeletonRenderer_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_updateWorldTransform) + +static bool js_cc_SkeletonRenderer_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setToSetupPose) + +static bool js_cc_SkeletonRenderer_setBonesToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setBonesToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setBonesToSetupPose) + +static bool js_cc_SkeletonRenderer_setSlotsToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setSlotsToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSlotsToSetupPose) + +static bool js_cc_SkeletonRenderer_paused(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->paused(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_paused) + +static bool js_cc_SkeletonRenderer_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Bone *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(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 = (spine::Bone *)((cc::SkeletonRenderer const *)arg1)->findBone((std::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_SkeletonRenderer_findBone) + +static bool js_cc_SkeletonRenderer_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Slot *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(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 = (spine::Slot *)((cc::SkeletonRenderer const *)arg1)->findSlot((std::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_SkeletonRenderer_findSlot) + +static bool js_cc_SkeletonRenderer_setSkin__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setSkin((std::string const &)*arg2); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setSkin__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + char *arg2 = (char *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + (arg1)->setSkin((char const *)arg2); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonRenderer_setSkin__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SkeletonRenderer_setSkin__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSkin) + +static bool js_cc_SkeletonRenderer_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *)((cc::SkeletonRenderer const *)arg1)->getAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getAttachment) + +static bool js_cc_SkeletonRenderer_setAttachment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setAttachment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + char *arg3 = (char *) NULL ; + std::string temp2 ; + ccstd::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(char const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_SkeletonRenderer_setAttachment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonRenderer_setAttachment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setAttachment) + +static bool js_cc_SkeletonRenderer_setUseTint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUseTint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setUseTint) + +static bool js_cc_SkeletonRenderer_setVertexEffectDelegate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::VertexEffectDelegate *arg2 = (cc::VertexEffectDelegate *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setVertexEffectDelegate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setVertexEffectDelegate) + +static bool js_cc_SkeletonRenderer_setSlotsRange(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + int arg2 ; + int arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSlotsRange(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSlotsRange) + +static bool js_cc_SkeletonRenderer_getDebugData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonRenderer const *)arg1)->getDebugData(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getDebugData) + +static bool js_cc_SkeletonRenderer_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonRenderer const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getSharedBufferOffset) + +static bool js_cc_SkeletonRenderer_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setColor) + +static bool js_cc_SkeletonRenderer_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setBatchEnabled) + +static bool js_cc_SkeletonRenderer_setDebugBonesEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugBonesEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setDebugBonesEnabled) + +static bool js_cc_SkeletonRenderer_setDebugSlotsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugSlotsEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setDebugSlotsEnabled) + +static bool js_cc_SkeletonRenderer_setDebugMeshEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugMeshEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setDebugMeshEnabled) + +static bool js_cc_SkeletonRenderer_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setAttachEnabled) + +static bool js_cc_SkeletonRenderer_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setOpacityModifyRGB) + +static bool js_cc_SkeletonRenderer_isOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::SkeletonRenderer const *)arg1)->isOpacityModifyRGB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_isOpacityModifyRGB) + +static bool js_cc_SkeletonRenderer_beginSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_beginSchedule) + +static bool js_cc_SkeletonRenderer_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_stopSchedule) + +static bool js_cc_SkeletonRenderer_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_onEnable) + +static bool js_cc_SkeletonRenderer_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_onDisable) + +static bool js_new_cc_SkeletonRenderer__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::SkeletonRenderer *result; + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + bool arg2 ; + bool arg3 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + bool arg2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + bool arg2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer((std::string const &)*arg1,(std::string const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer((std::string const &)*arg1,(std::string const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_SkeletonRenderer__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_SkeletonRenderer__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_SkeletonRenderer__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_SkeletonRenderer__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_SkeletonRenderer__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_SkeletonRenderer__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_SkeletonRenderer__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_SkeletonRenderer__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_SkeletonRenderer__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of SkeletonRenderer"); + return false; +} +SE_BIND_CTOR(js_new_cc_SkeletonRenderer, __jsb_cc_SkeletonRenderer_class, js_delete_cc_SkeletonRenderer) + +static bool js_delete_cc_SkeletonRenderer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonRenderer) + +static bool js_cc_SkeletonRenderer_initWithUUID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initWithUUID((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_initWithUUID) + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + bool arg4 ; + bool arg5 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + bool arg4 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2,arg3); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_initWithSkeleton) + +static bool js_cc_SkeletonRenderer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_initialize) + +static bool js_cc_SkeletonRenderer_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setMaterial) + +static bool js_cc_SkeletonRenderer_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setRenderEntity) + +static bool js_cc_SkeletonRenderer_setSlotTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + cc::Texture2D *arg3 = (cc::Texture2D *) NULL ; + bool arg4 ; + std::string temp2 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSlotTexture((std::string const &)*arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSlotTexture) + +bool js_register_cc_SkeletonRenderer(se::Object* obj) { + auto* cls = se::Class::create("SkeletonRenderer", obj, nullptr, _SE(js_new_cc_SkeletonRenderer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_SkeletonRenderer_update)); + cls->defineFunction("render", _SE(js_cc_SkeletonRenderer_render)); + cls->defineFunction("getBoundingBox", _SE(js_cc_SkeletonRenderer_getBoundingBox)); + cls->defineFunction("getSkeleton", _SE(js_cc_SkeletonRenderer_getSkeleton)); + cls->defineFunction("setTimeScale", _SE(js_cc_SkeletonRenderer_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_cc_SkeletonRenderer_getTimeScale)); + cls->defineFunction("updateWorldTransform", _SE(js_cc_SkeletonRenderer_updateWorldTransform)); + cls->defineFunction("setToSetupPose", _SE(js_cc_SkeletonRenderer_setToSetupPose)); + cls->defineFunction("setBonesToSetupPose", _SE(js_cc_SkeletonRenderer_setBonesToSetupPose)); + cls->defineFunction("setSlotsToSetupPose", _SE(js_cc_SkeletonRenderer_setSlotsToSetupPose)); + cls->defineFunction("paused", _SE(js_cc_SkeletonRenderer_paused)); + cls->defineFunction("findBone", _SE(js_cc_SkeletonRenderer_findBone)); + cls->defineFunction("findSlot", _SE(js_cc_SkeletonRenderer_findSlot)); + cls->defineFunction("setSkin", _SE(js_cc_SkeletonRenderer_setSkin)); + cls->defineFunction("getAttachment", _SE(js_cc_SkeletonRenderer_getAttachment)); + cls->defineFunction("setAttachment", _SE(js_cc_SkeletonRenderer_setAttachment)); + cls->defineFunction("setUseTint", _SE(js_cc_SkeletonRenderer_setUseTint)); + cls->defineFunction("setVertexEffectDelegate", _SE(js_cc_SkeletonRenderer_setVertexEffectDelegate)); + cls->defineFunction("setSlotsRange", _SE(js_cc_SkeletonRenderer_setSlotsRange)); + cls->defineFunction("getDebugData", _SE(js_cc_SkeletonRenderer_getDebugData)); + cls->defineFunction("getSharedBufferOffset", _SE(js_cc_SkeletonRenderer_getSharedBufferOffset)); + cls->defineFunction("setColor", _SE(js_cc_SkeletonRenderer_setColor)); + cls->defineFunction("setBatchEnabled", _SE(js_cc_SkeletonRenderer_setBatchEnabled)); + cls->defineFunction("setDebugBonesEnabled", _SE(js_cc_SkeletonRenderer_setDebugBonesEnabled)); + cls->defineFunction("setDebugSlotsEnabled", _SE(js_cc_SkeletonRenderer_setDebugSlotsEnabled)); + cls->defineFunction("setDebugMeshEnabled", _SE(js_cc_SkeletonRenderer_setDebugMeshEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_cc_SkeletonRenderer_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_cc_SkeletonRenderer_setOpacityModifyRGB)); + cls->defineFunction("isOpacityModifyRGB", _SE(js_cc_SkeletonRenderer_isOpacityModifyRGB)); + cls->defineFunction("beginSchedule", _SE(js_cc_SkeletonRenderer_beginSchedule)); + cls->defineFunction("stopSchedule", _SE(js_cc_SkeletonRenderer_stopSchedule)); + cls->defineFunction("onEnable", _SE(js_cc_SkeletonRenderer_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_SkeletonRenderer_onDisable)); + cls->defineFunction("initWithUUID", _SE(js_cc_SkeletonRenderer_initWithUUID)); + cls->defineFunction("initWithSkeleton", _SE(js_cc_SkeletonRenderer_initWithSkeleton)); + cls->defineFunction("initialize", _SE(js_cc_SkeletonRenderer_initialize)); + cls->defineFunction("setMaterial", _SE(js_cc_SkeletonRenderer_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_cc_SkeletonRenderer_setRenderEntity)); + cls->defineFunction("setSlotTexture", _SE(js_cc_SkeletonRenderer_setSlotTexture)); + + + cls->defineStaticFunction("create", _SE(js_cc_SkeletonRenderer_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonRenderer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonRenderer_proto = cls->getProto(); + __jsb_cc_SkeletonRenderer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CacheEventInfo_class = nullptr; +se::Object* __jsb_cc_CacheEventInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CacheEventInfo) + +static bool js_cc_CacheEventInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CacheEventInfo_type_set) + +static bool js_cc_CacheEventInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CacheEventInfo_type_get) + +static bool js_cc_CacheEventInfo_entry_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->entry, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CacheEventInfo_entry_set) + +static bool js_cc_CacheEventInfo_entry_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->entry, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->entry, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CacheEventInfo_entry_get) + +static bool js_cc_CacheEventInfo_event_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->event, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CacheEventInfo_event_set) + +static bool js_cc_CacheEventInfo_event_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->event, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->event, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CacheEventInfo_event_get) + +static bool js_new_cc_CacheEventInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::CacheEventInfo *result; + result = (cc::CacheEventInfo *)new cc::CacheEventInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CacheEventInfo, __jsb_cc_CacheEventInfo_class, js_delete_cc_CacheEventInfo) + +static bool js_delete_cc_CacheEventInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CacheEventInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::CacheEventInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("entry", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->entry), ctx); + } + + + json->getProperty("event", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->event), ctx); + } + + + return ok; +} + + +bool js_register_cc_CacheEventInfo(se::Object* obj) { + auto* cls = se::Class::create("CacheEventInfo", obj, nullptr, _SE(js_new_cc_CacheEventInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_CacheEventInfo_type_get), _SE(js_cc_CacheEventInfo_type_set)); + cls->defineProperty("entry", _SE(js_cc_CacheEventInfo_entry_get), _SE(js_cc_CacheEventInfo_entry_set)); + cls->defineProperty("event", _SE(js_cc_CacheEventInfo_event_get), _SE(js_cc_CacheEventInfo_event_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CacheEventInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CacheEventInfo_proto = cls->getProto(); + __jsb_cc_CacheEventInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonAnimation_class = nullptr; +se::Object* __jsb_cc_SkeletonAnimation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonAnimation) + +static bool js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithJsonFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithJsonFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithJsonFile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_createWithJsonFile_static) + +static bool js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithBinaryFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithBinaryFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithBinaryFile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_createWithBinaryFile_static) + +static bool js_cc_SkeletonAnimation_setGlobalTimeScale_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::SkeletonAnimation::setGlobalTimeScale(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setGlobalTimeScale_static) + +static bool js_cc_SkeletonAnimation_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_update) + +static bool js_cc_SkeletonAnimation_setAnimationStateData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::AnimationStateData *arg2 = (spine::AnimationStateData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAnimationStateData(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setAnimationStateData) + +static bool js_cc_SkeletonAnimation_setMix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + float arg4 ; + std::string temp2 ; + std::string temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMix((std::string const &)*arg2,(std::string const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setMix) + +static bool js_cc_SkeletonAnimation_setAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + std::string *arg3 = 0 ; + bool arg4 ; + std::string temp3 ; + spine::TrackEntry *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->setAnimation(arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setAnimation) + +static bool js_cc_SkeletonAnimation_addAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + std::string *arg3 = 0 ; + bool arg4 ; + float arg5 ; + std::string temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,(std::string const &)*arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_SkeletonAnimation_addAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + std::string *arg3 = 0 ; + bool arg4 ; + std::string temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_SkeletonAnimation_addAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_SkeletonAnimation_addAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_SkeletonAnimation_addAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_addAnimation) + +static bool js_cc_SkeletonAnimation_setEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + float arg3 ; + spine::TrackEntry *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(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 = (spine::TrackEntry *)(arg1)->setEmptyAnimation(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_SkeletonAnimation_setEmptyAnimation) + +static bool js_cc_SkeletonAnimation_setEmptyAnimations(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEmptyAnimations(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setEmptyAnimations) + +static bool js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addEmptyAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + float arg3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::TrackEntry *)(arg1)->addEmptyAnimation(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_SkeletonAnimation_addEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_addEmptyAnimation) + +static bool js_cc_SkeletonAnimation_findAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Animation *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(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 = (spine::Animation *)((cc::SkeletonAnimation const *)arg1)->findAnimation((std::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_SkeletonAnimation_findAnimation) + +static bool js_cc_SkeletonAnimation_getCurrent__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->getCurrent(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_SkeletonAnimation_getCurrent__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)(arg1)->getCurrent(); + + 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_SkeletonAnimation_getCurrent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonAnimation_getCurrent__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_SkeletonAnimation_getCurrent__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_getCurrent) + +static bool js_cc_SkeletonAnimation_clearTracks(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearTracks(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_clearTracks) + +static bool js_cc_SkeletonAnimation_clearTrack__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->clearTrack(arg2); + + + return true; +} + +static bool js_cc_SkeletonAnimation_clearTrack__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearTrack(); + + + return true; +} + +static bool js_cc_SkeletonAnimation_clearTrack(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonAnimation_clearTrack__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_SkeletonAnimation_clearTrack__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_clearTrack) + +static bool js_cc_SkeletonAnimation_setStartListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::StartListener *arg2 = 0 ; + cc::StartListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStartListener((cc::StartListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setStartListener) + +static bool js_cc_SkeletonAnimation_setInterruptListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::InterruptListener *arg2 = 0 ; + cc::InterruptListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setInterruptListener((cc::InterruptListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setInterruptListener) + +static bool js_cc_SkeletonAnimation_setEndListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::EndListener *arg2 = 0 ; + cc::EndListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEndListener((cc::EndListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setEndListener) + +static bool js_cc_SkeletonAnimation_setDisposeListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::DisposeListener *arg2 = 0 ; + cc::DisposeListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDisposeListener((cc::DisposeListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setDisposeListener) + +static bool js_cc_SkeletonAnimation_setCompleteListenerNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::CompleteListener *arg2 = 0 ; + cc::CompleteListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCompleteListener((cc::CompleteListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setCompleteListenerNative) + +static bool js_cc_SkeletonAnimation_setEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::EventListener *arg2 = 0 ; + cc::EventListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEventListener((cc::EventListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setEventListener) + +static bool js_cc_SkeletonAnimation_setTrackStartListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::StartListener *arg3 = 0 ; + cc::StartListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackStartListener(arg2,(cc::StartListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackStartListener) + +static bool js_cc_SkeletonAnimation_setTrackInterruptListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::InterruptListener *arg3 = 0 ; + cc::InterruptListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackInterruptListener(arg2,(cc::InterruptListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackInterruptListener) + +static bool js_cc_SkeletonAnimation_setTrackEndListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::EndListener *arg3 = 0 ; + cc::EndListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackEndListener(arg2,(cc::EndListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackEndListener) + +static bool js_cc_SkeletonAnimation_setTrackDisposeListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::DisposeListener *arg3 = 0 ; + cc::DisposeListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackDisposeListener(arg2,(cc::DisposeListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackDisposeListener) + +static bool js_cc_SkeletonAnimation_setTrackCompleteListenerNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::CompleteListener *arg3 = 0 ; + cc::CompleteListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackCompleteListener(arg2,(cc::CompleteListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackCompleteListenerNative) + +static bool js_cc_SkeletonAnimation_setTrackEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::EventListener *arg3 = 0 ; + cc::EventListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackEventListener(arg2,(cc::EventListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackEventListener) + +static bool js_cc_SkeletonAnimation_getState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::AnimationState *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(s); + if (nullptr == arg1) return true; + result = (spine::AnimationState *)((cc::SkeletonAnimation const *)arg1)->getState(); + + 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_SkeletonAnimation_getState) + +static bool js_new_cc_SkeletonAnimation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkeletonAnimation *result; + result = (cc::SkeletonAnimation *)new cc::SkeletonAnimation(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonAnimation, __jsb_cc_SkeletonAnimation_class, js_delete_cc_SkeletonAnimation) + +static bool js_delete_cc_SkeletonAnimation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonAnimation) + +bool js_register_cc_SkeletonAnimation(se::Object* obj) { + auto* cls = se::Class::create("SkeletonAnimation", obj, __jsb_cc_SkeletonRenderer_proto, _SE(js_new_cc_SkeletonAnimation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_SkeletonAnimation_update)); + cls->defineFunction("setAnimationStateData", _SE(js_cc_SkeletonAnimation_setAnimationStateData)); + cls->defineFunction("setMix", _SE(js_cc_SkeletonAnimation_setMix)); + cls->defineFunction("setAnimation", _SE(js_cc_SkeletonAnimation_setAnimation)); + cls->defineFunction("addAnimation", _SE(js_cc_SkeletonAnimation_addAnimation)); + cls->defineFunction("setEmptyAnimation", _SE(js_cc_SkeletonAnimation_setEmptyAnimation)); + cls->defineFunction("setEmptyAnimations", _SE(js_cc_SkeletonAnimation_setEmptyAnimations)); + cls->defineFunction("addEmptyAnimation", _SE(js_cc_SkeletonAnimation_addEmptyAnimation)); + cls->defineFunction("findAnimation", _SE(js_cc_SkeletonAnimation_findAnimation)); + cls->defineFunction("getCurrent", _SE(js_cc_SkeletonAnimation_getCurrent)); + cls->defineFunction("clearTracks", _SE(js_cc_SkeletonAnimation_clearTracks)); + cls->defineFunction("clearTrack", _SE(js_cc_SkeletonAnimation_clearTrack)); + cls->defineFunction("setStartListener", _SE(js_cc_SkeletonAnimation_setStartListener)); + cls->defineFunction("setInterruptListener", _SE(js_cc_SkeletonAnimation_setInterruptListener)); + cls->defineFunction("setEndListener", _SE(js_cc_SkeletonAnimation_setEndListener)); + cls->defineFunction("setDisposeListener", _SE(js_cc_SkeletonAnimation_setDisposeListener)); + cls->defineFunction("setCompleteListenerNative", _SE(js_cc_SkeletonAnimation_setCompleteListenerNative)); + cls->defineFunction("setEventListener", _SE(js_cc_SkeletonAnimation_setEventListener)); + cls->defineFunction("setTrackStartListener", _SE(js_cc_SkeletonAnimation_setTrackStartListener)); + cls->defineFunction("setTrackInterruptListener", _SE(js_cc_SkeletonAnimation_setTrackInterruptListener)); + cls->defineFunction("setTrackEndListener", _SE(js_cc_SkeletonAnimation_setTrackEndListener)); + cls->defineFunction("setTrackDisposeListener", _SE(js_cc_SkeletonAnimation_setTrackDisposeListener)); + cls->defineFunction("setTrackCompleteListenerNative", _SE(js_cc_SkeletonAnimation_setTrackCompleteListenerNative)); + cls->defineFunction("setTrackEventListener", _SE(js_cc_SkeletonAnimation_setTrackEventListener)); + cls->defineFunction("getState", _SE(js_cc_SkeletonAnimation_getState)); + + + cls->defineStaticFunction("createWithJsonFile", _SE(js_cc_SkeletonAnimation_createWithJsonFile_static)); + cls->defineStaticFunction("createWithBinaryFile", _SE(js_cc_SkeletonAnimation_createWithBinaryFile_static)); + cls->defineStaticFunction("setGlobalTimeScale", _SE(js_cc_SkeletonAnimation_setGlobalTimeScale_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonAnimation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonAnimation_proto = cls->getProto(); + __jsb_cc_SkeletonAnimation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonDataMgr_class = nullptr; +se::Object* __jsb_cc_SkeletonDataMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonDataMgr) + +static bool js_cc_SkeletonDataMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonDataMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::SkeletonDataMgr *)cc::SkeletonDataMgr::getInstance(); + + 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_SkeletonDataMgr_getInstance_static) + +static bool js_new_cc_SkeletonDataMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkeletonDataMgr *result; + result = (cc::SkeletonDataMgr *)new cc::SkeletonDataMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonDataMgr, __jsb_cc_SkeletonDataMgr_class, js_delete_cc_SkeletonDataMgr) + +static bool js_delete_cc_SkeletonDataMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonDataMgr) + +static bool js_cc_SkeletonDataMgr_setDestroyCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonDataMgr *arg1 = (cc::SkeletonDataMgr *) NULL ; + cc::SkeletonDataMgr::destroyCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDestroyCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonDataMgr_setDestroyCallback) + +static bool js_cc_SkeletonDataMgr_getSkeletonDataInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonDataMgr *arg1 = (cc::SkeletonDataMgr *) NULL ; + std::vector< cc::SkeletonDataInfo * > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonDataMgr const *)arg1)->getSkeletonDataInfos(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonDataMgr_getSkeletonDataInfos) + +bool js_register_cc_SkeletonDataMgr(se::Object* obj) { + auto* cls = se::Class::create("SkeletonDataMgr", obj, nullptr, _SE(js_new_cc_SkeletonDataMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setDestroyCallback", _SE(js_cc_SkeletonDataMgr_setDestroyCallback)); + cls->defineFunction("getSkeletonDataInfos", _SE(js_cc_SkeletonDataMgr_getSkeletonDataInfos)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_SkeletonDataMgr_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonDataMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonDataMgr_proto = cls->getProto(); + __jsb_cc_SkeletonDataMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonCacheAnimation_class = nullptr; +se::Object* __jsb_cc_SkeletonCacheAnimation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonCacheAnimation) + +static bool js_new_cc_SkeletonCacheAnimation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + std::string *arg1 = 0 ; + bool arg2 ; + std::string temp1 ; + cc::SkeletonCacheAnimation *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonCacheAnimation *)new cc::SkeletonCacheAnimation((std::string const &)*arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonCacheAnimation, __jsb_cc_SkeletonCacheAnimation_class, js_delete_cc_SkeletonCacheAnimation) + +static bool js_delete_cc_SkeletonCacheAnimation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonCacheAnimation) + +static bool js_cc_SkeletonCacheAnimation_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_update) + +static bool js_cc_SkeletonCacheAnimation_getSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + spine::Skeleton *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(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *)((cc::SkeletonCacheAnimation const *)arg1)->getSkeleton(); + + 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_SkeletonCacheAnimation_getSkeleton) + +static bool js_cc_SkeletonCacheAnimation_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setTimeScale) + +static bool js_cc_SkeletonCacheAnimation_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::SkeletonCacheAnimation const *)arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_getTimeScale) + +static bool js_cc_SkeletonCacheAnimation_paused(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->paused(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_paused) + +static bool js_cc_SkeletonCacheAnimation_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Bone *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(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 = (spine::Bone *)((cc::SkeletonCacheAnimation const *)arg1)->findBone((std::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_SkeletonCacheAnimation_findBone) + +static bool js_cc_SkeletonCacheAnimation_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Slot *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(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 = (spine::Slot *)((cc::SkeletonCacheAnimation const *)arg1)->findSlot((std::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_SkeletonCacheAnimation_findSlot) + +static bool js_cc_SkeletonCacheAnimation_setSkin__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setSkin((std::string const &)*arg2); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setSkin__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + char *arg2 = (char *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + (arg1)->setSkin((char const *)arg2); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonCacheAnimation_setSkin__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SkeletonCacheAnimation_setSkin__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setSkin) + +static bool js_cc_SkeletonCacheAnimation_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *)((cc::SkeletonCacheAnimation const *)arg1)->getAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_getAttachment) + +static bool js_cc_SkeletonCacheAnimation_setAttachment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setAttachment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + char *arg3 = (char *) NULL ; + std::string temp2 ; + ccstd::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(char const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_SkeletonCacheAnimation_setAttachment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonCacheAnimation_setAttachment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setAttachment) + +static bool js_cc_SkeletonCacheAnimation_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setColor) + +static bool js_cc_SkeletonCacheAnimation_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setBatchEnabled) + +static bool js_cc_SkeletonCacheAnimation_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setAttachEnabled) + +static bool js_cc_SkeletonCacheAnimation_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setOpacityModifyRGB) + +static bool js_cc_SkeletonCacheAnimation_isOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::SkeletonCacheAnimation const *)arg1)->isOpacityModifyRGB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_isOpacityModifyRGB) + +static bool js_cc_SkeletonCacheAnimation_beginSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_beginSchedule) + +static bool js_cc_SkeletonCacheAnimation_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_stopSchedule) + +static bool js_cc_SkeletonCacheAnimation_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_onEnable) + +static bool js_cc_SkeletonCacheAnimation_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_onDisable) + +static bool js_cc_SkeletonCacheAnimation_setUseTint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUseTint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setUseTint) + +static bool js_cc_SkeletonCacheAnimation_setAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::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(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)->setAnimation((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setAnimation) + +static bool js_cc_SkeletonCacheAnimation_addAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + float arg4 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addAnimation((std::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_addAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addAnimation((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_addAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonCacheAnimation_addAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonCacheAnimation_addAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_addAnimation) + +static bool js_cc_SkeletonCacheAnimation_findAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Animation *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(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 = (spine::Animation *)((cc::SkeletonCacheAnimation const *)arg1)->findAnimation((std::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_SkeletonCacheAnimation_findAnimation) + +static bool js_cc_SkeletonCacheAnimation_setStartListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::SkeletonCacheAnimation::CacheFrameEvent *arg2 = 0 ; + cc::SkeletonCacheAnimation::CacheFrameEvent temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStartListener((cc::SkeletonCacheAnimation::CacheFrameEvent const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setStartListener) + +static bool js_cc_SkeletonCacheAnimation_setEndListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::SkeletonCacheAnimation::CacheFrameEvent *arg2 = 0 ; + cc::SkeletonCacheAnimation::CacheFrameEvent temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEndListener((cc::SkeletonCacheAnimation::CacheFrameEvent const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setEndListener) + +static bool js_cc_SkeletonCacheAnimation_setCompleteListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::SkeletonCacheAnimation::CacheFrameEvent *arg2 = 0 ; + cc::SkeletonCacheAnimation::CacheFrameEvent temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCompleteListener((cc::SkeletonCacheAnimation::CacheFrameEvent const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setCompleteListener) + +static bool js_cc_SkeletonCacheAnimation_updateAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateAnimationCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_updateAnimationCache) + +static bool js_cc_SkeletonCacheAnimation_updateAllAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateAllAnimationCache(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_updateAllAnimationCache) + +static bool js_cc_SkeletonCacheAnimation_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setToSetupPose) + +static bool js_cc_SkeletonCacheAnimation_setBonesToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setBonesToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setBonesToSetupPose) + +static bool js_cc_SkeletonCacheAnimation_setSlotsToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setSlotsToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setSlotsToSetupPose) + +static bool js_cc_SkeletonCacheAnimation_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonCacheAnimation const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_getSharedBufferOffset) + +static bool js_cc_SkeletonCacheAnimation_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setMaterial) + +static bool js_cc_SkeletonCacheAnimation_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setRenderEntity) + +bool js_register_cc_SkeletonCacheAnimation(se::Object* obj) { + auto* cls = se::Class::create("SkeletonCacheAnimation", obj, nullptr, _SE(js_new_cc_SkeletonCacheAnimation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_SkeletonCacheAnimation_update)); + cls->defineFunction("getSkeleton", _SE(js_cc_SkeletonCacheAnimation_getSkeleton)); + cls->defineFunction("setTimeScale", _SE(js_cc_SkeletonCacheAnimation_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_cc_SkeletonCacheAnimation_getTimeScale)); + cls->defineFunction("paused", _SE(js_cc_SkeletonCacheAnimation_paused)); + cls->defineFunction("findBone", _SE(js_cc_SkeletonCacheAnimation_findBone)); + cls->defineFunction("findSlot", _SE(js_cc_SkeletonCacheAnimation_findSlot)); + cls->defineFunction("setSkin", _SE(js_cc_SkeletonCacheAnimation_setSkin)); + cls->defineFunction("getAttachment", _SE(js_cc_SkeletonCacheAnimation_getAttachment)); + cls->defineFunction("setAttachment", _SE(js_cc_SkeletonCacheAnimation_setAttachment)); + cls->defineFunction("setColor", _SE(js_cc_SkeletonCacheAnimation_setColor)); + cls->defineFunction("setBatchEnabled", _SE(js_cc_SkeletonCacheAnimation_setBatchEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_cc_SkeletonCacheAnimation_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_cc_SkeletonCacheAnimation_setOpacityModifyRGB)); + cls->defineFunction("isOpacityModifyRGB", _SE(js_cc_SkeletonCacheAnimation_isOpacityModifyRGB)); + cls->defineFunction("beginSchedule", _SE(js_cc_SkeletonCacheAnimation_beginSchedule)); + cls->defineFunction("stopSchedule", _SE(js_cc_SkeletonCacheAnimation_stopSchedule)); + cls->defineFunction("onEnable", _SE(js_cc_SkeletonCacheAnimation_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_SkeletonCacheAnimation_onDisable)); + cls->defineFunction("setUseTint", _SE(js_cc_SkeletonCacheAnimation_setUseTint)); + cls->defineFunction("setAnimation", _SE(js_cc_SkeletonCacheAnimation_setAnimation)); + cls->defineFunction("addAnimation", _SE(js_cc_SkeletonCacheAnimation_addAnimation)); + cls->defineFunction("findAnimation", _SE(js_cc_SkeletonCacheAnimation_findAnimation)); + cls->defineFunction("setStartListener", _SE(js_cc_SkeletonCacheAnimation_setStartListener)); + cls->defineFunction("setEndListener", _SE(js_cc_SkeletonCacheAnimation_setEndListener)); + cls->defineFunction("setCompleteListener", _SE(js_cc_SkeletonCacheAnimation_setCompleteListener)); + cls->defineFunction("updateAnimationCache", _SE(js_cc_SkeletonCacheAnimation_updateAnimationCache)); + cls->defineFunction("updateAllAnimationCache", _SE(js_cc_SkeletonCacheAnimation_updateAllAnimationCache)); + cls->defineFunction("setToSetupPose", _SE(js_cc_SkeletonCacheAnimation_setToSetupPose)); + cls->defineFunction("setBonesToSetupPose", _SE(js_cc_SkeletonCacheAnimation_setBonesToSetupPose)); + cls->defineFunction("setSlotsToSetupPose", _SE(js_cc_SkeletonCacheAnimation_setSlotsToSetupPose)); + cls->defineFunction("getSharedBufferOffset", _SE(js_cc_SkeletonCacheAnimation_getSharedBufferOffset)); + cls->defineFunction("setMaterial", _SE(js_cc_SkeletonCacheAnimation_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_cc_SkeletonCacheAnimation_setRenderEntity)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonCacheAnimation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonCacheAnimation_proto = cls->getProto(); + __jsb_cc_SkeletonCacheAnimation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonCacheMgr_class = nullptr; +se::Object* __jsb_cc_SkeletonCacheMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonCacheMgr) + +static bool js_cc_SkeletonCacheMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::SkeletonCacheMgr *)cc::SkeletonCacheMgr::getInstance(); + + 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_SkeletonCacheMgr_getInstance_static) + +static bool js_cc_SkeletonCacheMgr_destroyInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::SkeletonCacheMgr::destroyInstance(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheMgr_destroyInstance_static) + +static bool js_cc_SkeletonCacheMgr_removeSkeletonCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheMgr *arg1 = (cc::SkeletonCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeSkeletonCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheMgr_removeSkeletonCache) + +static bool js_cc_SkeletonCacheMgr_buildSkeletonCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheMgr *arg1 = (cc::SkeletonCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + cc::SkeletonCache *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(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::SkeletonCache *)(arg1)->buildSkeletonCache((std::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_SkeletonCacheMgr_buildSkeletonCache) + +static bool js_new_cc_SkeletonCacheMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkeletonCacheMgr *result; + result = (cc::SkeletonCacheMgr *)new cc::SkeletonCacheMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonCacheMgr, __jsb_cc_SkeletonCacheMgr_class, js_delete_cc_SkeletonCacheMgr) + +static bool js_delete_cc_SkeletonCacheMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonCacheMgr) + +bool js_register_cc_SkeletonCacheMgr(se::Object* obj) { + auto* cls = se::Class::create("SkeletonCacheMgr", obj, nullptr, _SE(js_new_cc_SkeletonCacheMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("removeSkeletonCache", _SE(js_cc_SkeletonCacheMgr_removeSkeletonCache)); + cls->defineFunction("buildSkeletonCache", _SE(js_cc_SkeletonCacheMgr_buildSkeletonCache)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_SkeletonCacheMgr_getInstance_static)); + cls->defineStaticFunction("destroyInstance", _SE(js_cc_SkeletonCacheMgr_destroyInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonCacheMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonCacheMgr_proto = cls->getProto(); + __jsb_cc_SkeletonCacheMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_spine(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("spine", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("spine", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_spine_MathUtil(ns); + js_register_spine_Interpolation(ns); + js_register_spine_PowInterpolation(ns); + js_register_spine_PowOutInterpolation(ns); + js_register_spine_Timeline(ns); + js_register_spine_Animation(ns); + js_register_spine_AnimationStateListenerObject(ns); + js_register_spine_TrackEntry(ns); + js_register_spine_EventQueueEntry(ns); + js_register_spine_EventQueue(ns); + js_register_spine_AnimationState(ns); + js_register_spine_AnimationStateData(ns); + js_register_spine_Attachment(ns); + js_register_spine_AttachmentTimeline(ns); + js_register_spine_VertexAttachment(ns); + js_register_spine_BoundingBoxAttachment(ns); + js_register_spine_Bone(ns); + js_register_spine_BoneData(ns); + js_register_spine_ClippingAttachment(ns); + js_register_spine_Color(ns); + js_register_spine_CurveTimeline(ns); + js_register_spine_ColorTimeline(ns); + js_register_spine_DeformTimeline(ns); + js_register_spine_DrawOrderTimeline(ns); + js_register_spine_Event(ns); + js_register_spine_EventData(ns); + js_register_spine_EventTimeline(ns); + js_register_spine_ConstraintData(ns); + js_register_spine_IkConstraint(ns); + js_register_spine_IkConstraintData(ns); + js_register_spine_IkConstraintTimeline(ns); + js_register_spine_MeshAttachment(ns); + js_register_spine_PathAttachment(ns); + js_register_spine_PathConstraint(ns); + js_register_spine_PathConstraintData(ns); + js_register_spine_PathConstraintMixTimeline(ns); + js_register_spine_PathConstraintPositionTimeline(ns); + js_register_spine_PathConstraintSpacingTimeline(ns); + js_register_spine_PointAttachment(ns); + js_register_spine_RegionAttachment(ns); + js_register_spine_TranslateTimeline(ns); + js_register_spine_TwoColorTimeline(ns); + js_register_spine_RotateTimeline(ns); + js_register_spine_ScaleTimeline(ns); + js_register_spine_ShearTimeline(ns); + js_register_spine_Skeleton(ns); + js_register_spine_Slot(ns); + js_register_spine_Skin(ns); + js_register_spine_Skin_AttachmentMap(ns); + js_register_spine_Skin_AttachmentMap_Entry(ns); + js_register_spine_Skin_AttachmentMap_Entries(ns); + js_register_spine_SkeletonBounds(ns); + js_register_spine_Polygon(ns); + js_register_spine_SkeletonData(ns); + js_register_spine_SlotData(ns); + js_register_spine_SkeletonBinary(ns); + js_register_spine_AttachmentLoader(ns); + js_register_spine_AtlasPage(ns); + js_register_spine_AtlasRegion(ns); + js_register_spine_Atlas(ns); + js_register_spine_TextureLoader(ns); + js_register_spine_TransformConstraint(ns); + js_register_spine_TransformConstraintData(ns); + js_register_spine_TransformConstraintTimeline(ns); + js_register_spine_VertexEffect(ns); + js_register_spine_JitterVertexEffect(ns); + js_register_spine_SwirlVertexEffect(ns); + js_register_cc_VertexEffectDelegate(ns); + js_register_cc_SkeletonRenderer(ns); + js_register_cc_CacheEventInfo(ns); + js_register_cc_SkeletonAnimation(ns); + js_register_cc_SkeletonDataMgr(ns); + js_register_cc_SkeletonCacheAnimation(ns); + js_register_cc_SkeletonCacheMgr(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 diff --git a/native/build_android/generated/cocos/bindings/auto/jsb_spine_3_8_auto.h b/native/build_android/generated/cocos/bindings/auto/jsb_spine_3_8_auto.h new file mode 100644 index 0000000000..0186d68505 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/jsb_spine_3_8_auto.h @@ -0,0 +1,435 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "editor-support/spine-creator-support/spine-cocos2dx.h" +#include "editor-support/spine-creator-support/Vector2.h" + + + +bool register_all_spine(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(spine::MathUtil); +extern se::Object *__jsb_spine_MathUtil_proto; // NOLINT +extern se::Class * __jsb_spine_MathUtil_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Interpolation); +extern se::Object *__jsb_spine_Interpolation_proto; // NOLINT +extern se::Class * __jsb_spine_Interpolation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::Interpolation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::PowInterpolation); +extern se::Object *__jsb_spine_PowInterpolation_proto; // NOLINT +extern se::Class * __jsb_spine_PowInterpolation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowInterpolation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::PowOutInterpolation); +extern se::Object *__jsb_spine_PowOutInterpolation_proto; // NOLINT +extern se::Class * __jsb_spine_PowOutInterpolation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowOutInterpolation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::Timeline); +extern se::Object *__jsb_spine_Timeline_proto; // NOLINT +extern se::Class * __jsb_spine_Timeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Animation); +extern se::Object *__jsb_spine_Animation_proto; // NOLINT +extern se::Class * __jsb_spine_Animation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AnimationStateListenerObject); +extern se::Object *__jsb_spine_AnimationStateListenerObject_proto; // NOLINT +extern se::Class * __jsb_spine_AnimationStateListenerObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TrackEntry); +extern se::Object *__jsb_spine_TrackEntry_proto; // NOLINT +extern se::Class * __jsb_spine_TrackEntry_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventQueueEntry); +extern se::Object *__jsb_spine_EventQueueEntry_proto; // NOLINT +extern se::Class * __jsb_spine_EventQueueEntry_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventQueue); +extern se::Object *__jsb_spine_EventQueue_proto; // NOLINT +extern se::Class * __jsb_spine_EventQueue_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AnimationState); +extern se::Object *__jsb_spine_AnimationState_proto; // NOLINT +extern se::Class * __jsb_spine_AnimationState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AnimationStateData); +extern se::Object *__jsb_spine_AnimationStateData_proto; // NOLINT +extern se::Class * __jsb_spine_AnimationStateData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Attachment); +extern se::Object *__jsb_spine_Attachment_proto; // NOLINT +extern se::Class * __jsb_spine_Attachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AttachmentTimeline); +extern se::Object *__jsb_spine_AttachmentTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_AttachmentTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::VertexAttachment); +extern se::Object *__jsb_spine_VertexAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_VertexAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::BoundingBoxAttachment); +extern se::Object *__jsb_spine_BoundingBoxAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_BoundingBoxAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Bone); +extern se::Object *__jsb_spine_Bone_proto; // NOLINT +extern se::Class * __jsb_spine_Bone_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::BoneData); +extern se::Object *__jsb_spine_BoneData_proto; // NOLINT +extern se::Class * __jsb_spine_BoneData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ClippingAttachment); +extern se::Object *__jsb_spine_ClippingAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_ClippingAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Color); +extern se::Object *__jsb_spine_Color_proto; // NOLINT +extern se::Class * __jsb_spine_Color_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::CurveTimeline); +extern se::Object *__jsb_spine_CurveTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_CurveTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ColorTimeline); +extern se::Object *__jsb_spine_ColorTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_ColorTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::DeformTimeline); +extern se::Object *__jsb_spine_DeformTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_DeformTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::DrawOrderTimeline); +extern se::Object *__jsb_spine_DrawOrderTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_DrawOrderTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Event); +extern se::Object *__jsb_spine_Event_proto; // NOLINT +extern se::Class * __jsb_spine_Event_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventData); +extern se::Object *__jsb_spine_EventData_proto; // NOLINT +extern se::Class * __jsb_spine_EventData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventTimeline); +extern se::Object *__jsb_spine_EventTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_EventTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ConstraintData); +extern se::Object *__jsb_spine_ConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_ConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::IkConstraint); +extern se::Object *__jsb_spine_IkConstraint_proto; // NOLINT +extern se::Class * __jsb_spine_IkConstraint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::IkConstraintData); +extern se::Object *__jsb_spine_IkConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_IkConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::IkConstraintTimeline); +extern se::Object *__jsb_spine_IkConstraintTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_IkConstraintTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::MeshAttachment); +extern se::Object *__jsb_spine_MeshAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_MeshAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathAttachment); +extern se::Object *__jsb_spine_PathAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_PathAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraint); +extern se::Object *__jsb_spine_PathConstraint_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintData); +extern se::Object *__jsb_spine_PathConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintMixTimeline); +extern se::Object *__jsb_spine_PathConstraintMixTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintMixTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintPositionTimeline); +extern se::Object *__jsb_spine_PathConstraintPositionTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintPositionTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintSpacingTimeline); +extern se::Object *__jsb_spine_PathConstraintSpacingTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintSpacingTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PointAttachment); +extern se::Object *__jsb_spine_PointAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_PointAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::RegionAttachment); +extern se::Object *__jsb_spine_RegionAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_RegionAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TranslateTimeline); +extern se::Object *__jsb_spine_TranslateTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_TranslateTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TwoColorTimeline); +extern se::Object *__jsb_spine_TwoColorTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_TwoColorTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::RotateTimeline); +extern se::Object *__jsb_spine_RotateTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_RotateTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ScaleTimeline); +extern se::Object *__jsb_spine_ScaleTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_ScaleTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ShearTimeline); +extern se::Object *__jsb_spine_ShearTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_ShearTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skeleton); +extern se::Object *__jsb_spine_Skeleton_proto; // NOLINT +extern se::Class * __jsb_spine_Skeleton_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Slot); +extern se::Object *__jsb_spine_Slot_proto; // NOLINT +extern se::Class * __jsb_spine_Slot_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin::AttachmentMap::Entry); +extern se::Object *__jsb_spine_Skin_AttachmentMap_Entry_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_AttachmentMap_Entry_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::Skin::AttachmentMap::Entry * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin::AttachmentMap::Entries); +extern se::Object *__jsb_spine_Skin_AttachmentMap_Entries_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_AttachmentMap_Entries_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin::AttachmentMap); +extern se::Object *__jsb_spine_Skin_AttachmentMap_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_AttachmentMap_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin); +extern se::Object *__jsb_spine_Skin_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SkeletonBounds); +extern se::Object *__jsb_spine_SkeletonBounds_proto; // NOLINT +extern se::Class * __jsb_spine_SkeletonBounds_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Polygon); +extern se::Object *__jsb_spine_Polygon_proto; // NOLINT +extern se::Class * __jsb_spine_Polygon_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SkeletonData); +extern se::Object *__jsb_spine_SkeletonData_proto; // NOLINT +extern se::Class * __jsb_spine_SkeletonData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SlotData); +extern se::Object *__jsb_spine_SlotData_proto; // NOLINT +extern se::Class * __jsb_spine_SlotData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SkeletonBinary); +extern se::Object *__jsb_spine_SkeletonBinary_proto; // NOLINT +extern se::Class * __jsb_spine_SkeletonBinary_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AttachmentLoader); +extern se::Object *__jsb_spine_AttachmentLoader_proto; // NOLINT +extern se::Class * __jsb_spine_AttachmentLoader_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AtlasPage); +extern se::Object *__jsb_spine_AtlasPage_proto; // NOLINT +extern se::Class * __jsb_spine_AtlasPage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AtlasRegion); +extern se::Object *__jsb_spine_AtlasRegion_proto; // NOLINT +extern se::Class * __jsb_spine_AtlasRegion_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Atlas); +extern se::Object *__jsb_spine_Atlas_proto; // NOLINT +extern se::Class * __jsb_spine_Atlas_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TextureLoader); +extern se::Object *__jsb_spine_TextureLoader_proto; // NOLINT +extern se::Class * __jsb_spine_TextureLoader_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TransformConstraint); +extern se::Object *__jsb_spine_TransformConstraint_proto; // NOLINT +extern se::Class * __jsb_spine_TransformConstraint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TransformConstraintData); +extern se::Object *__jsb_spine_TransformConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_TransformConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TransformConstraintTimeline); +extern se::Object *__jsb_spine_TransformConstraintTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_TransformConstraintTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::VertexEffect); +extern se::Object *__jsb_spine_VertexEffect_proto; // NOLINT +extern se::Class * __jsb_spine_VertexEffect_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::JitterVertexEffect); +extern se::Object *__jsb_spine_JitterVertexEffect_proto; // NOLINT +extern se::Class * __jsb_spine_JitterVertexEffect_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SwirlVertexEffect); +extern se::Object *__jsb_spine_SwirlVertexEffect_proto; // NOLINT +extern se::Class * __jsb_spine_SwirlVertexEffect_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::VertexEffectDelegate); +extern se::Object *__jsb_cc_VertexEffectDelegate_proto; // NOLINT +extern se::Class * __jsb_cc_VertexEffectDelegate_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonRenderer); +extern se::Object *__jsb_cc_SkeletonRenderer_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonRenderer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CacheEventInfo); +extern se::Object *__jsb_cc_CacheEventInfo_proto; // NOLINT +extern se::Class * __jsb_cc_CacheEventInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::CacheEventInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonAnimation); +extern se::Object *__jsb_cc_SkeletonAnimation_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonAnimation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonDataMgr); +extern se::Object *__jsb_cc_SkeletonDataMgr_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonDataMgr_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonCacheAnimation); +extern se::Object *__jsb_cc_SkeletonCacheAnimation_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonCacheAnimation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonCacheMgr); +extern se::Object *__jsb_cc_SkeletonCacheMgr_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonCacheMgr_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_2d_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_2d_auto.cpp new file mode 100644 index 0000000000..7e63eebcaa --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_2d_auto.cpp @@ -0,0 +1,3618 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_2d_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_assets_auto.h" + + +#define cc_UIMeshBuffer_vData_get(self_) self_->getVData() +#define cc_UIMeshBuffer_vData_set(self_, val_) self_->setVData(val_) + + +#define cc_UIMeshBuffer_iData_get(self_) self_->getIData() +#define cc_UIMeshBuffer_iData_set(self_, val_) self_->setIData(val_) + + +#define cc_RenderDrawInfo_bufferId_get(self_) self_->getBufferId() +#define cc_RenderDrawInfo_bufferId_set(self_, val_) self_->setBufferId(val_) + + +#define cc_RenderDrawInfo_accId_get(self_) self_->getAccId() +#define cc_RenderDrawInfo_accId_set(self_, val_) self_->setAccId(val_) + + +#define cc_RenderDrawInfo_vertexOffset_get(self_) self_->getVertexOffset() +#define cc_RenderDrawInfo_vertexOffset_set(self_, val_) self_->setVertexOffset(val_) + + +#define cc_RenderDrawInfo_indexOffset_get(self_) self_->getIndexOffset() +#define cc_RenderDrawInfo_indexOffset_set(self_, val_) self_->setIndexOffset(val_) + + +#define cc_RenderDrawInfo_vbCount_get(self_) self_->getVbCount() +#define cc_RenderDrawInfo_vbCount_set(self_, val_) self_->setVbCount(val_) + + +#define cc_RenderDrawInfo_ibCount_get(self_) self_->getIbCount() +#define cc_RenderDrawInfo_ibCount_set(self_, val_) self_->setIbCount(val_) + + +#define cc_RenderDrawInfo_vertDirty_get(self_) self_->getVertDirty() +#define cc_RenderDrawInfo_vertDirty_set(self_, val_) self_->setVertDirty(val_) + + +#define cc_RenderDrawInfo_dataHash_get(self_) self_->getDataHash() +#define cc_RenderDrawInfo_dataHash_set(self_, val_) self_->setDataHash(val_) + + +#define cc_RenderDrawInfo_isMeshBuffer_get(self_) self_->getIsMeshBuffer() +#define cc_RenderDrawInfo_isMeshBuffer_set(self_, val_) self_->setIsMeshBuffer(val_) + + +#define cc_RenderDrawInfo_vbBuffer_get(self_) self_->getVbBuffer() +#define cc_RenderDrawInfo_vbBuffer_set(self_, val_) self_->setVbBuffer(val_) + + +#define cc_RenderDrawInfo_ibBuffer_get(self_) self_->getIbBuffer() +#define cc_RenderDrawInfo_ibBuffer_set(self_, val_) self_->setIbBuffer(val_) + + +#define cc_RenderDrawInfo_vDataBuffer_get(self_) self_->getVDataBuffer() +#define cc_RenderDrawInfo_vDataBuffer_set(self_, val_) self_->setVDataBuffer(val_) + + +#define cc_RenderDrawInfo_iDataBuffer_get(self_) self_->getIDataBuffer() +#define cc_RenderDrawInfo_iDataBuffer_set(self_, val_) self_->setIDataBuffer(val_) + + +#define cc_RenderDrawInfo_material_get(self_) self_->getMaterial() +#define cc_RenderDrawInfo_material_set(self_, val_) self_->setMaterial(val_) + + +#define cc_RenderDrawInfo_texture_get(self_) self_->getTexture() +#define cc_RenderDrawInfo_texture_set(self_, val_) self_->setTexture(val_) + + +#define cc_RenderDrawInfo_sampler_get(self_) self_->getSampler() +#define cc_RenderDrawInfo_sampler_set(self_, val_) self_->setSampler(val_) + + +#define cc_RenderDrawInfo_model_get(self_) self_->getModel() +#define cc_RenderDrawInfo_model_set(self_, val_) self_->setModel(val_) + + +#define cc_RenderDrawInfo_drawInfoType_get(self_) self_->getDrawInfoType() +#define cc_RenderDrawInfo_drawInfoType_set(self_, val_) self_->setDrawInfoType(val_) + + +#define cc_RenderDrawInfo_subNode_get(self_) self_->getSubNode() +#define cc_RenderDrawInfo_subNode_set(self_, val_) self_->setSubNode(val_) + + +#define cc_RenderDrawInfo_stride_get(self_) self_->getStride() +#define cc_RenderDrawInfo_stride_set(self_, val_) self_->setStride(val_) + + +#define cc_RenderEntity_node_get(self_) self_->getNode() +#define cc_RenderEntity_node_set(self_, val_) self_->setNode(val_) + + +#define cc_RenderEntity_renderTransform_get(self_) self_->getRenderTransform() +#define cc_RenderEntity_renderTransform_set(self_, val_) self_->setRenderTransform(val_) + + +#define cc_RenderEntity_staticDrawInfoSize_get(self_) self_->getStaticDrawInfoSize() +#define cc_RenderEntity_staticDrawInfoSize_set(self_, val_) self_->setStaticDrawInfoSize(val_) + + +#define cc_RenderEntity_stencilStage_get(self_) self_->getStencilStage() +#define cc_RenderEntity_stencilStage_set(self_, val_) self_->setStencilStage(val_) + + + +se::Class* __jsb_cc_MeshBufferLayout_class = nullptr; +se::Object* __jsb_cc_MeshBufferLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MeshBufferLayout) + +static bool js_cc_MeshBufferLayout_byteOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->byteOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_byteOffset_set) + +static bool js_cc_MeshBufferLayout_byteOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->byteOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_byteOffset_get) + +static bool js_cc_MeshBufferLayout_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_vertexOffset_set) + +static bool js_cc_MeshBufferLayout_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_vertexOffset_get) + +static bool js_cc_MeshBufferLayout_indexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_indexOffset_set) + +static bool js_cc_MeshBufferLayout_indexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_indexOffset_get) + +static bool js_cc_MeshBufferLayout_dirtyMark_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dirtyMark, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MeshBufferLayout_dirtyMark_set) + +static bool js_cc_MeshBufferLayout_dirtyMark_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MeshBufferLayout *arg1 = (cc::MeshBufferLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dirtyMark, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MeshBufferLayout_dirtyMark_get) + +static bool js_new_cc_MeshBufferLayout(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MeshBufferLayout *result; + result = (cc::MeshBufferLayout *)new cc::MeshBufferLayout(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MeshBufferLayout, __jsb_cc_MeshBufferLayout_class, js_delete_cc_MeshBufferLayout) + +static bool js_delete_cc_MeshBufferLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MeshBufferLayout) + +template<> +bool sevalue_to_native(const se::Value &from, cc::MeshBufferLayout * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("byteOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->byteOffset), ctx); + } + + + json->getProperty("vertexOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexOffset), ctx); + } + + + json->getProperty("indexOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexOffset), ctx); + } + + + json->getProperty("dirtyMark", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dirtyMark), ctx); + } + + + return ok; +} + + +bool js_register_cc_MeshBufferLayout(se::Object* obj) { + auto* cls = se::Class::create("MeshBufferLayout", obj, nullptr, _SE(js_new_cc_MeshBufferLayout)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("byteOffset", _SE(js_cc_MeshBufferLayout_byteOffset_get), _SE(js_cc_MeshBufferLayout_byteOffset_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_MeshBufferLayout_vertexOffset_get), _SE(js_cc_MeshBufferLayout_vertexOffset_set)); + cls->defineProperty("indexOffset", _SE(js_cc_MeshBufferLayout_indexOffset_get), _SE(js_cc_MeshBufferLayout_indexOffset_set)); + cls->defineProperty("dirtyMark", _SE(js_cc_MeshBufferLayout_dirtyMark_get), _SE(js_cc_MeshBufferLayout_dirtyMark_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MeshBufferLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MeshBufferLayout_proto = cls->getProto(); + __jsb_cc_MeshBufferLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_UIMeshBuffer_class = nullptr; +se::Object* __jsb_cc_UIMeshBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_UIMeshBuffer) + +static bool js_new_cc_UIMeshBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::UIMeshBuffer *result; + result = (cc::UIMeshBuffer *)new cc::UIMeshBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_UIMeshBuffer, __jsb_cc_UIMeshBuffer_class, js_delete_cc_UIMeshBuffer) + +static bool js_delete_cc_UIMeshBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_UIMeshBuffer) + +static bool js_cc_UIMeshBuffer_initialize__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + ccstd::vector< cc::gfx::Attribute > *arg2 = 0 ; + bool arg3 ; + ccstd::vector< cc::gfx::Attribute > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((ccstd::vector< cc::gfx::Attribute > &&)*arg2,arg3); + + + return true; +} + +static bool js_cc_UIMeshBuffer_initialize__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + ccstd::vector< cc::gfx::Attribute > *arg2 = 0 ; + ccstd::vector< cc::gfx::Attribute > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((ccstd::vector< cc::gfx::Attribute > &&)*arg2); + + + return true; +} + +static bool js_cc_UIMeshBuffer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_UIMeshBuffer_initialize__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_UIMeshBuffer_initialize__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_initialize) + +static bool js_cc_UIMeshBuffer_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_reset) + +static bool js_cc_UIMeshBuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_destroy) + +static bool js_cc_UIMeshBuffer_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_uploadBuffers) + +static bool js_cc_UIMeshBuffer_syncSharedBufferToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + uint32_t *arg2 = (uint32_t *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->syncSharedBufferToNative(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIMeshBuffer_syncSharedBufferToNative) + +static bool js_cc_UIMeshBuffer_vData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + float *arg2 = (float *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_UIMeshBuffer_vData_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_UIMeshBuffer_vData_set) + +static bool js_cc_UIMeshBuffer_vData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + float *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float *)cc_UIMeshBuffer_vData_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_UIMeshBuffer_vData_get) + +static bool js_cc_UIMeshBuffer_iData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + uint16_t *arg2 = (uint16_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_UIMeshBuffer_iData_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_UIMeshBuffer_iData_set) + +static bool js_cc_UIMeshBuffer_iData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::UIMeshBuffer *arg1 = (cc::UIMeshBuffer *) NULL ; + uint16_t *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (uint16_t *)cc_UIMeshBuffer_iData_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_UIMeshBuffer_iData_get) + +bool js_register_cc_UIMeshBuffer(se::Object* obj) { + auto* cls = se::Class::create("UIMeshBuffer", obj, nullptr, _SE(js_new_cc_UIMeshBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vData", _SE(js_cc_UIMeshBuffer_vData_get), _SE(js_cc_UIMeshBuffer_vData_set)); + cls->defineProperty("iData", _SE(js_cc_UIMeshBuffer_iData_get), _SE(js_cc_UIMeshBuffer_iData_set)); + + cls->defineFunction("initialize", _SE(js_cc_UIMeshBuffer_initialize)); + cls->defineFunction("reset", _SE(js_cc_UIMeshBuffer_reset)); + cls->defineFunction("destroy", _SE(js_cc_UIMeshBuffer_destroy)); + cls->defineFunction("uploadBuffers", _SE(js_cc_UIMeshBuffer_uploadBuffers)); + cls->defineFunction("syncSharedBufferToNative", _SE(js_cc_UIMeshBuffer_syncSharedBufferToNative)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_UIMeshBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_UIMeshBuffer_proto = cls->getProto(); + __jsb_cc_UIMeshBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Render2dLayout_class = nullptr; +se::Object* __jsb_cc_Render2dLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Render2dLayout) + +static bool js_cc_Render2dLayout_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Render2dLayout_position_set) + +static bool js_cc_Render2dLayout_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Render2dLayout_position_get) + +static bool js_cc_Render2dLayout_uv_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uv, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Render2dLayout_uv_set) + +static bool js_cc_Render2dLayout_uv_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uv, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uv, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Render2dLayout_uv_get) + +static bool js_cc_Render2dLayout_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Render2dLayout_color_set) + +static bool js_cc_Render2dLayout_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Render2dLayout *arg1 = (cc::Render2dLayout *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Render2dLayout_color_get) + +static bool js_new_cc_Render2dLayout(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Render2dLayout *result; + result = (cc::Render2dLayout *)new cc::Render2dLayout(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Render2dLayout, __jsb_cc_Render2dLayout_class, js_delete_cc_Render2dLayout) + +static bool js_delete_cc_Render2dLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Render2dLayout) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Render2dLayout * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("position", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->position), ctx); + } + + + json->getProperty("uv", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uv), ctx); + } + + + json->getProperty("color", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->color), ctx); + } + + + return ok; +} + + +bool js_register_cc_Render2dLayout(se::Object* obj) { + auto* cls = se::Class::create("Render2dLayout", obj, nullptr, _SE(js_new_cc_Render2dLayout)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_Render2dLayout_position_get), _SE(js_cc_Render2dLayout_position_set)); + cls->defineProperty("uv", _SE(js_cc_Render2dLayout_uv_get), _SE(js_cc_Render2dLayout_uv_set)); + cls->defineProperty("color", _SE(js_cc_Render2dLayout_color_get), _SE(js_cc_Render2dLayout_color_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Render2dLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Render2dLayout_proto = cls->getProto(); + __jsb_cc_Render2dLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_LocalDSBF_class = nullptr; +se::Object* __jsb_cc_LocalDSBF_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_LocalDSBF) + +static bool js_cc_LocalDSBF_ds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_LocalDSBF_ds_set) + +static bool js_cc_LocalDSBF_ds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ds, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ds, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_LocalDSBF_ds_get) + +static bool js_cc_LocalDSBF_uboBuf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uboBuf, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_LocalDSBF_uboBuf_set) + +static bool js_cc_LocalDSBF_uboBuf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::LocalDSBF *arg1 = (cc::LocalDSBF *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uboBuf, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uboBuf, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_LocalDSBF_uboBuf_get) + +static bool js_new_cc_LocalDSBF(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::LocalDSBF *result; + result = (cc::LocalDSBF *)new cc::LocalDSBF(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_LocalDSBF, __jsb_cc_LocalDSBF_class, js_delete_cc_LocalDSBF) + +static bool js_delete_cc_LocalDSBF(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_LocalDSBF) + +template<> +bool sevalue_to_native(const se::Value &from, cc::LocalDSBF * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("ds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ds), ctx); + } + + + json->getProperty("uboBuf", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uboBuf), ctx); + } + + + return ok; +} + + +bool js_register_cc_LocalDSBF(se::Object* obj) { + auto* cls = se::Class::create("LocalDSBF", obj, nullptr, _SE(js_new_cc_LocalDSBF)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("ds", _SE(js_cc_LocalDSBF_ds_get), _SE(js_cc_LocalDSBF_ds_set)); + cls->defineProperty("uboBuf", _SE(js_cc_LocalDSBF_uboBuf_get), _SE(js_cc_LocalDSBF_uboBuf_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_LocalDSBF)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_LocalDSBF_proto = cls->getProto(); + __jsb_cc_LocalDSBF_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderDrawInfo_class = nullptr; +se::Object* __jsb_cc_RenderDrawInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderDrawInfo) + +static bool js_new_cc_RenderDrawInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RenderDrawInfo *result; + result = (cc::RenderDrawInfo *)new cc::RenderDrawInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RenderDrawInfo, __jsb_cc_RenderDrawInfo_class, js_delete_cc_RenderDrawInfo) + +static bool js_delete_cc_RenderDrawInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderDrawInfo) + +static bool js_cc_RenderDrawInfo_isVertexPositionInWorld(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderDrawInfo const *)arg1)->isVertexPositionInWorld(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_isVertexPositionInWorld) + +static bool js_cc_RenderDrawInfo_setMeshBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::UIMeshBuffer *arg2 = (cc::UIMeshBuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMeshBuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_setMeshBuffer) + +static bool js_cc_RenderDrawInfo_getMeshBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::UIMeshBuffer *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(s); + if (nullptr == arg1) return true; + result = (cc::UIMeshBuffer *)((cc::RenderDrawInfo const *)arg1)->getMeshBuffer(); + + 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_RenderDrawInfo_getMeshBuffer) + +static bool js_cc_RenderDrawInfo_changeMeshBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->changeMeshBuffer(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_changeMeshBuffer) + +static bool js_cc_RenderDrawInfo_setRender2dBufferToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRender2dBufferToNative(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_setRender2dBufferToNative) + +static bool js_cc_RenderDrawInfo_getAttrSharedBufferForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + se::Object *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(s); + if (nullptr == arg1) return true; + result = (se::Object *)((cc::RenderDrawInfo const *)arg1)->getAttrSharedBufferForJS(); + + 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_RenderDrawInfo_getAttrSharedBufferForJS) + +static bool js_cc_RenderDrawInfo_requestIA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::gfx::InputAssembler *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::InputAssembler *)(arg1)->requestIA(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_RenderDrawInfo_requestIA) + +static bool js_cc_RenderDrawInfo_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_uploadBuffers) + +static bool js_cc_RenderDrawInfo_resetMeshIA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetMeshIA(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_resetMeshIA) + +static bool js_cc_RenderDrawInfo_getLocalDes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)(arg1)->getLocalDes(); + + 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_RenderDrawInfo_getLocalDes) + +static bool js_cc_RenderDrawInfo_updateLocalDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + cc::gfx::DescriptorSetLayout *arg3 = (cc::gfx::DescriptorSetLayout *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLocalDescriptorSet(arg2,(cc::gfx::DescriptorSetLayout const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderDrawInfo_updateLocalDescriptorSet) + +static bool js_cc_RenderDrawInfo_bufferId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_bufferId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_bufferId_set) + +static bool js_cc_RenderDrawInfo_bufferId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_bufferId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_bufferId_get) + +static bool js_cc_RenderDrawInfo_accId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_accId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_accId_set) + +static bool js_cc_RenderDrawInfo_accId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_accId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_accId_get) + +static bool js_cc_RenderDrawInfo_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_vertexOffset_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vertexOffset_set) + +static bool js_cc_RenderDrawInfo_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_vertexOffset_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_vertexOffset_get) + +static bool js_cc_RenderDrawInfo_indexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_indexOffset_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_indexOffset_set) + +static bool js_cc_RenderDrawInfo_indexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_indexOffset_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_indexOffset_get) + +static bool js_cc_RenderDrawInfo_vbCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_vbCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vbCount_set) + +static bool js_cc_RenderDrawInfo_vbCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_vbCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_vbCount_get) + +static bool js_cc_RenderDrawInfo_ibCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_ibCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_ibCount_set) + +static bool js_cc_RenderDrawInfo_ibCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_ibCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_ibCount_get) + +static bool js_cc_RenderDrawInfo_vertDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_vertDirty_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vertDirty_set) + +static bool js_cc_RenderDrawInfo_vertDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_RenderDrawInfo_vertDirty_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_vertDirty_get) + +static bool js_cc_RenderDrawInfo_dataHash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_dataHash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_dataHash_set) + +static bool js_cc_RenderDrawInfo_dataHash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_dataHash_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_RenderDrawInfo_dataHash_get) + +static bool js_cc_RenderDrawInfo_isMeshBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_isMeshBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_isMeshBuffer_set) + +static bool js_cc_RenderDrawInfo_isMeshBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_RenderDrawInfo_isMeshBuffer_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_isMeshBuffer_get) + +static bool js_cc_RenderDrawInfo_vbBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *arg2 = (float *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_vbBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vbBuffer_set) + +static bool js_cc_RenderDrawInfo_vbBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float *)cc_RenderDrawInfo_vbBuffer_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_RenderDrawInfo_vbBuffer_get) + +static bool js_cc_RenderDrawInfo_ibBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *arg2 = (uint16_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_ibBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_ibBuffer_set) + +static bool js_cc_RenderDrawInfo_ibBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (uint16_t *)cc_RenderDrawInfo_ibBuffer_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_RenderDrawInfo_ibBuffer_get) + +static bool js_cc_RenderDrawInfo_vDataBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *arg2 = (float *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_vDataBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_vDataBuffer_set) + +static bool js_cc_RenderDrawInfo_vDataBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + float *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float *)cc_RenderDrawInfo_vDataBuffer_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_RenderDrawInfo_vDataBuffer_get) + +static bool js_cc_RenderDrawInfo_iDataBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *arg2 = (uint16_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_iDataBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_iDataBuffer_set) + +static bool js_cc_RenderDrawInfo_iDataBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint16_t *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (uint16_t *)cc_RenderDrawInfo_iDataBuffer_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_RenderDrawInfo_iDataBuffer_get) + +static bool js_cc_RenderDrawInfo_material_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_material_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_material_set) + +static bool js_cc_RenderDrawInfo_material_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_RenderDrawInfo_material_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_RenderDrawInfo_material_get) + +static bool js_cc_RenderDrawInfo_texture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_texture_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_texture_set) + +static bool js_cc_RenderDrawInfo_texture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_RenderDrawInfo_texture_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_RenderDrawInfo_texture_get) + +static bool js_cc_RenderDrawInfo_sampler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Sampler *arg2 = (cc::gfx::Sampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_sampler_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_sampler_set) + +static bool js_cc_RenderDrawInfo_sampler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::gfx::Sampler *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)cc_RenderDrawInfo_sampler_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_RenderDrawInfo_sampler_get) + +static bool js_cc_RenderDrawInfo_model_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_model_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_model_set) + +static bool js_cc_RenderDrawInfo_model_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_RenderDrawInfo_model_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_RenderDrawInfo_model_get) + +static bool js_cc_RenderDrawInfo_drawInfoType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_drawInfoType_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_drawInfoType_set) + +static bool js_cc_RenderDrawInfo_drawInfoType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_drawInfoType_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_drawInfoType_get) + +static bool js_cc_RenderDrawInfo_subNode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderDrawInfo_subNode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_subNode_set) + +static bool js_cc_RenderDrawInfo_subNode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_RenderDrawInfo_subNode_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_RenderDrawInfo_subNode_get) + +static bool js_cc_RenderDrawInfo_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint8_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderDrawInfo_stride_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderDrawInfo_stride_set) + +static bool js_cc_RenderDrawInfo_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderDrawInfo *arg1 = (cc::RenderDrawInfo *) NULL ; + uint8_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderDrawInfo_stride_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderDrawInfo_stride_get) + +bool js_register_cc_RenderDrawInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderDrawInfo", obj, nullptr, _SE(js_new_cc_RenderDrawInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bufferId", _SE(js_cc_RenderDrawInfo_bufferId_get), _SE(js_cc_RenderDrawInfo_bufferId_set)); + cls->defineProperty("accId", _SE(js_cc_RenderDrawInfo_accId_get), _SE(js_cc_RenderDrawInfo_accId_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_RenderDrawInfo_vertexOffset_get), _SE(js_cc_RenderDrawInfo_vertexOffset_set)); + cls->defineProperty("indexOffset", _SE(js_cc_RenderDrawInfo_indexOffset_get), _SE(js_cc_RenderDrawInfo_indexOffset_set)); + cls->defineProperty("vbCount", _SE(js_cc_RenderDrawInfo_vbCount_get), _SE(js_cc_RenderDrawInfo_vbCount_set)); + cls->defineProperty("ibCount", _SE(js_cc_RenderDrawInfo_ibCount_get), _SE(js_cc_RenderDrawInfo_ibCount_set)); + cls->defineProperty("vertDirty", _SE(js_cc_RenderDrawInfo_vertDirty_get), _SE(js_cc_RenderDrawInfo_vertDirty_set)); + cls->defineProperty("dataHash", _SE(js_cc_RenderDrawInfo_dataHash_get), _SE(js_cc_RenderDrawInfo_dataHash_set)); + cls->defineProperty("isMeshBuffer", _SE(js_cc_RenderDrawInfo_isMeshBuffer_get), _SE(js_cc_RenderDrawInfo_isMeshBuffer_set)); + cls->defineProperty("vbBuffer", _SE(js_cc_RenderDrawInfo_vbBuffer_get), _SE(js_cc_RenderDrawInfo_vbBuffer_set)); + cls->defineProperty("ibBuffer", _SE(js_cc_RenderDrawInfo_ibBuffer_get), _SE(js_cc_RenderDrawInfo_ibBuffer_set)); + cls->defineProperty("vDataBuffer", _SE(js_cc_RenderDrawInfo_vDataBuffer_get), _SE(js_cc_RenderDrawInfo_vDataBuffer_set)); + cls->defineProperty("iDataBuffer", _SE(js_cc_RenderDrawInfo_iDataBuffer_get), _SE(js_cc_RenderDrawInfo_iDataBuffer_set)); + cls->defineProperty("material", _SE(js_cc_RenderDrawInfo_material_get), _SE(js_cc_RenderDrawInfo_material_set)); + cls->defineProperty("texture", _SE(js_cc_RenderDrawInfo_texture_get), _SE(js_cc_RenderDrawInfo_texture_set)); + cls->defineProperty("sampler", _SE(js_cc_RenderDrawInfo_sampler_get), _SE(js_cc_RenderDrawInfo_sampler_set)); + cls->defineProperty("model", _SE(js_cc_RenderDrawInfo_model_get), _SE(js_cc_RenderDrawInfo_model_set)); + cls->defineProperty("drawInfoType", _SE(js_cc_RenderDrawInfo_drawInfoType_get), _SE(js_cc_RenderDrawInfo_drawInfoType_set)); + cls->defineProperty("subNode", _SE(js_cc_RenderDrawInfo_subNode_get), _SE(js_cc_RenderDrawInfo_subNode_set)); + cls->defineProperty("stride", _SE(js_cc_RenderDrawInfo_stride_get), _SE(js_cc_RenderDrawInfo_stride_set)); + + cls->defineFunction("isVertexPositionInWorld", _SE(js_cc_RenderDrawInfo_isVertexPositionInWorld)); + cls->defineFunction("setMeshBuffer", _SE(js_cc_RenderDrawInfo_setMeshBuffer)); + cls->defineFunction("getMeshBuffer", _SE(js_cc_RenderDrawInfo_getMeshBuffer)); + cls->defineFunction("changeMeshBuffer", _SE(js_cc_RenderDrawInfo_changeMeshBuffer)); + cls->defineFunction("setRender2dBufferToNative", _SE(js_cc_RenderDrawInfo_setRender2dBufferToNative)); + cls->defineFunction("getAttrSharedBufferForJS", _SE(js_cc_RenderDrawInfo_getAttrSharedBufferForJS)); + cls->defineFunction("requestIA", _SE(js_cc_RenderDrawInfo_requestIA)); + cls->defineFunction("uploadBuffers", _SE(js_cc_RenderDrawInfo_uploadBuffers)); + cls->defineFunction("resetMeshIA", _SE(js_cc_RenderDrawInfo_resetMeshIA)); + cls->defineFunction("getLocalDes", _SE(js_cc_RenderDrawInfo_getLocalDes)); + cls->defineFunction("updateLocalDescriptorSet", _SE(js_cc_RenderDrawInfo_updateLocalDescriptorSet)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderDrawInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderDrawInfo_proto = cls->getProto(); + __jsb_cc_RenderDrawInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderEntity_class = nullptr; +se::Object* __jsb_cc_RenderEntity_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderEntity) + +static bool js_new_cc_RenderEntity(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::RenderEntityType arg1 ; + cc::RenderEntity *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderEntity *)new cc::RenderEntity(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RenderEntity, __jsb_cc_RenderEntity_class, js_delete_cc_RenderEntity) + +static bool js_delete_cc_RenderEntity(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderEntity) + +static bool js_cc_RenderEntity_addDynamicRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::RenderDrawInfo *arg2 = (cc::RenderDrawInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDynamicRenderDrawInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_addDynamicRenderDrawInfo) + +static bool js_cc_RenderEntity_setDynamicRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::RenderDrawInfo *arg2 = (cc::RenderDrawInfo *) NULL ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDynamicRenderDrawInfo(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_setDynamicRenderDrawInfo) + +static bool js_cc_RenderEntity_removeDynamicRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeDynamicRenderDrawInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_removeDynamicRenderDrawInfo) + +static bool js_cc_RenderEntity_clearDynamicRenderDrawInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearDynamicRenderDrawInfos(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_clearDynamicRenderDrawInfos) + +static bool js_cc_RenderEntity_clearStaticRenderDrawInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearStaticRenderDrawInfos(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_clearStaticRenderDrawInfos) + +static bool js_cc_RenderEntity_getIsMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getIsMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getIsMask) + +static bool js_cc_RenderEntity_getIsSubMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getIsSubMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getIsSubMask) + +static bool js_cc_RenderEntity_getIsMaskInverted(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getIsMaskInverted(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getIsMaskInverted) + +static bool js_cc_RenderEntity_getUseLocal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::RenderEntity const *)arg1)->getUseLocal(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getUseLocal) + +static bool js_cc_RenderEntity_setUseLocal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUseLocal(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_setUseLocal) + +static bool js_cc_RenderEntity_getFillColorType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::FillColorType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::FillColorType)((cc::RenderEntity const *)arg1)->getFillColorType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getFillColorType) + +static bool js_cc_RenderEntity_getStaticRenderDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + cc::RenderDrawInfo *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderDrawInfo *)(arg1)->getStaticRenderDrawInfo(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_RenderEntity_getStaticRenderDrawInfo) + +static bool js_cc_RenderEntity_getStaticRenderDrawInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + std::array< cc::RenderDrawInfo,4 > *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(s); + if (nullptr == arg1) return true; + result = (std::array< cc::RenderDrawInfo,4 > *) &(arg1)->getStaticRenderDrawInfos(); + + 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_RenderEntity_getStaticRenderDrawInfos) + +static bool js_cc_RenderEntity_getEntitySharedBufferForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + se::Object *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(s); + if (nullptr == arg1) return true; + result = (se::Object *)((cc::RenderEntity const *)arg1)->getEntitySharedBufferForJS(); + + 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_RenderEntity_getEntitySharedBufferForJS) + +static bool js_cc_RenderEntity_getColorAlpha(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::RenderEntity const *)arg1)->getColorAlpha(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getColorAlpha) + +static bool js_cc_RenderEntity_getOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::RenderEntity const *)arg1)->getOpacity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getOpacity) + +static bool js_cc_RenderEntity_setOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_setOpacity) + +static bool js_cc_RenderEntity_getRenderDrawInfosSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::RenderEntity const *)arg1)->getRenderDrawInfosSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getRenderDrawInfosSize) + +static bool js_cc_RenderEntity_getRenderDrawInfoAt(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + cc::RenderDrawInfo *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderDrawInfo *)(arg1)->getRenderDrawInfoAt(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_RenderEntity_getRenderDrawInfoAt) + +static bool js_cc_RenderEntity_getPriority(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::RenderEntity const *)arg1)->getPriority(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderEntity_getPriority) + +static bool js_cc_RenderEntity_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderEntity_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_node_set) + +static bool js_cc_RenderEntity_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_RenderEntity_node_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_RenderEntity_node_get) + +static bool js_cc_RenderEntity_renderTransform_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderEntity_renderTransform_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_renderTransform_set) + +static bool js_cc_RenderEntity_renderTransform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_RenderEntity_renderTransform_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_RenderEntity_renderTransform_get) + +static bool js_cc_RenderEntity_staticDrawInfoSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderEntity_staticDrawInfoSize_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_staticDrawInfoSize_set) + +static bool js_cc_RenderEntity_staticDrawInfoSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderEntity_staticDrawInfoSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderEntity_staticDrawInfoSize_get) + +static bool js_cc_RenderEntity_stencilStage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_RenderEntity_stencilStage_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderEntity_stencilStage_set) + +static bool js_cc_RenderEntity_stencilStage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderEntity *arg1 = (cc::RenderEntity *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_RenderEntity_stencilStage_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RenderEntity_stencilStage_get) + +bool js_register_cc_RenderEntity(se::Object* obj) { + auto* cls = se::Class::create("RenderEntity", obj, nullptr, _SE(js_new_cc_RenderEntity)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("node", _SE(js_cc_RenderEntity_node_get), _SE(js_cc_RenderEntity_node_set)); + cls->defineProperty("renderTransform", _SE(js_cc_RenderEntity_renderTransform_get), _SE(js_cc_RenderEntity_renderTransform_set)); + cls->defineProperty("staticDrawInfoSize", _SE(js_cc_RenderEntity_staticDrawInfoSize_get), _SE(js_cc_RenderEntity_staticDrawInfoSize_set)); + cls->defineProperty("stencilStage", _SE(js_cc_RenderEntity_stencilStage_get), _SE(js_cc_RenderEntity_stencilStage_set)); + + cls->defineFunction("addDynamicRenderDrawInfo", _SE(js_cc_RenderEntity_addDynamicRenderDrawInfo)); + cls->defineFunction("setDynamicRenderDrawInfo", _SE(js_cc_RenderEntity_setDynamicRenderDrawInfo)); + cls->defineFunction("removeDynamicRenderDrawInfo", _SE(js_cc_RenderEntity_removeDynamicRenderDrawInfo)); + cls->defineFunction("clearDynamicRenderDrawInfos", _SE(js_cc_RenderEntity_clearDynamicRenderDrawInfos)); + cls->defineFunction("clearStaticRenderDrawInfos", _SE(js_cc_RenderEntity_clearStaticRenderDrawInfos)); + cls->defineFunction("getIsMask", _SE(js_cc_RenderEntity_getIsMask)); + cls->defineFunction("getIsSubMask", _SE(js_cc_RenderEntity_getIsSubMask)); + cls->defineFunction("getIsMaskInverted", _SE(js_cc_RenderEntity_getIsMaskInverted)); + cls->defineFunction("getUseLocal", _SE(js_cc_RenderEntity_getUseLocal)); + cls->defineFunction("setUseLocal", _SE(js_cc_RenderEntity_setUseLocal)); + cls->defineFunction("getFillColorType", _SE(js_cc_RenderEntity_getFillColorType)); + cls->defineFunction("getStaticRenderDrawInfo", _SE(js_cc_RenderEntity_getStaticRenderDrawInfo)); + cls->defineFunction("getStaticRenderDrawInfos", _SE(js_cc_RenderEntity_getStaticRenderDrawInfos)); + cls->defineFunction("getEntitySharedBufferForJS", _SE(js_cc_RenderEntity_getEntitySharedBufferForJS)); + cls->defineFunction("getColorAlpha", _SE(js_cc_RenderEntity_getColorAlpha)); + cls->defineFunction("getOpacity", _SE(js_cc_RenderEntity_getOpacity)); + cls->defineFunction("setOpacity", _SE(js_cc_RenderEntity_setOpacity)); + cls->defineFunction("getRenderDrawInfosSize", _SE(js_cc_RenderEntity_getRenderDrawInfosSize)); + cls->defineFunction("getRenderDrawInfoAt", _SE(js_cc_RenderEntity_getRenderDrawInfoAt)); + cls->defineFunction("getPriority", _SE(js_cc_RenderEntity_getPriority)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderEntity)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderEntity_proto = cls->getProto(); + __jsb_cc_RenderEntity_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_UIModelProxy_class = nullptr; +se::Object* __jsb_cc_UIModelProxy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_UIModelProxy) + +static bool js_new_cc_UIModelProxy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::UIModelProxy *result; + result = (cc::UIModelProxy *)new cc::UIModelProxy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_UIModelProxy, __jsb_cc_UIModelProxy_class, js_delete_cc_UIModelProxy) + +static bool js_delete_cc_UIModelProxy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_UIModelProxy) + +static bool js_cc_UIModelProxy_initModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_initModel) + +static bool js_cc_UIModelProxy_activeSubModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activeSubModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_activeSubModels) + +static bool js_cc_UIModelProxy_uploadData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadData(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_uploadData) + +static bool js_cc_UIModelProxy_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_destroy) + +static bool js_cc_UIModelProxy_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_clear) + +static bool js_cc_UIModelProxy_getModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::scene::Model *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)((cc::UIModelProxy const *)arg1)->getModel(); + + 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_UIModelProxy_getModel) + +static bool js_cc_UIModelProxy_updateModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateModels(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_updateModels) + +static bool js_cc_UIModelProxy_attachDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->attachDrawInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_attachDrawInfo) + +static bool js_cc_UIModelProxy_attachNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachNode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_attachNode) + +static bool js_cc_UIModelProxy_clearModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::UIModelProxy *arg1 = (cc::UIModelProxy *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_UIModelProxy_clearModels) + +bool js_register_cc_UIModelProxy(se::Object* obj) { + auto* cls = se::Class::create("UIModelProxy", obj, nullptr, _SE(js_new_cc_UIModelProxy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initModel", _SE(js_cc_UIModelProxy_initModel)); + cls->defineFunction("activeSubModels", _SE(js_cc_UIModelProxy_activeSubModels)); + cls->defineFunction("uploadData", _SE(js_cc_UIModelProxy_uploadData)); + cls->defineFunction("destroy", _SE(js_cc_UIModelProxy_destroy)); + cls->defineFunction("clear", _SE(js_cc_UIModelProxy_clear)); + cls->defineFunction("getModel", _SE(js_cc_UIModelProxy_getModel)); + cls->defineFunction("updateModels", _SE(js_cc_UIModelProxy_updateModels)); + cls->defineFunction("attachDrawInfo", _SE(js_cc_UIModelProxy_attachDrawInfo)); + cls->defineFunction("attachNode", _SE(js_cc_UIModelProxy_attachNode)); + cls->defineFunction("clearModels", _SE(js_cc_UIModelProxy_clearModels)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_UIModelProxy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_UIModelProxy_proto = cls->getProto(); + __jsb_cc_UIModelProxy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RecordedRendererInfo_class = nullptr; +se::Object* __jsb_cc_RecordedRendererInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RecordedRendererInfo) + +static bool js_cc_RecordedRendererInfo_renderEntity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RecordedRendererInfo *arg1 = (cc::RecordedRendererInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderEntity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RecordedRendererInfo_renderEntity_set) + +static bool js_cc_RecordedRendererInfo_renderEntity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RecordedRendererInfo *arg1 = (cc::RecordedRendererInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderEntity, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderEntity, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_RecordedRendererInfo_renderEntity_get) + +static bool js_new_cc_RecordedRendererInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RecordedRendererInfo *result; + result = (cc::RecordedRendererInfo *)new cc::RecordedRendererInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RecordedRendererInfo, __jsb_cc_RecordedRendererInfo_class, js_delete_cc_RecordedRendererInfo) + +static bool js_delete_cc_RecordedRendererInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RecordedRendererInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::RecordedRendererInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("renderEntity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderEntity), ctx); + } + + + return ok; +} + + +bool js_register_cc_RecordedRendererInfo(se::Object* obj) { + auto* cls = se::Class::create("RecordedRendererInfo", obj, nullptr, _SE(js_new_cc_RecordedRendererInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderEntity", _SE(js_cc_RecordedRendererInfo_renderEntity_get), _SE(js_cc_RecordedRendererInfo_renderEntity_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RecordedRendererInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RecordedRendererInfo_proto = cls->getProto(); + __jsb_cc_RecordedRendererInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Batcher2d_class = nullptr; +se::Object* __jsb_cc_Batcher2d_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Batcher2d) + +static bool js_cc_Batcher2d_setSorting2DCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int32_t arg1 ; + + 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::Batcher2d::setSorting2DCount(SWIG_STD_MOVE(arg1)); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_setSorting2DCount_static) + +static bool js_new_cc_Batcher2d__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Batcher2d *result; + result = (cc::Batcher2d *)new cc::Batcher2d(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Batcher2d__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::Batcher2d *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Batcher2d *)new cc::Batcher2d(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Batcher2d(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Batcher2d__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Batcher2d__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Batcher2d"); + return false; +} +SE_BIND_CTOR(js_new_cc_Batcher2d, __jsb_cc_Batcher2d_class, js_delete_cc_Batcher2d) + +static bool js_delete_cc_Batcher2d(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Batcher2d) + +static bool js_cc_Batcher2d_syncMeshBuffersToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + uint16_t arg2 ; + ccstd::vector< cc::UIMeshBuffer * > *arg3 = 0 ; + ccstd::vector< cc::UIMeshBuffer * > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->syncMeshBuffersToNative(arg2,(ccstd::vector< cc::UIMeshBuffer * > &&)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_syncMeshBuffersToNative) + +static bool js_cc_Batcher2d_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->initialize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_initialize) + +static bool js_cc_Batcher2d_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_update) + +static bool js_cc_Batcher2d_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->uploadBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_uploadBuffers) + +static bool js_cc_Batcher2d_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_reset) + +static bool js_cc_Batcher2d_syncRootNodesToNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + ccstd::vector< cc::Node * > *arg2 = 0 ; + ccstd::vector< cc::Node * > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->syncRootNodesToNative((ccstd::vector< cc::Node * > &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_syncRootNodesToNative) + +static bool js_cc_Batcher2d_releaseDescriptorSetCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->releaseDescriptorSetCache(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_releaseDescriptorSetCache) + +static bool js_cc_Batcher2d_getDefaultAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + ccstd::vector< cc::gfx::Attribute > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gfx::Attribute > *)(arg1)->getDefaultAttribute(); + + 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_Batcher2d_getDefaultAttribute) + +static bool js_cc_Batcher2d_handlePostRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Batcher2d *arg1 = (cc::Batcher2d *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->handlePostRender(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Batcher2d_handlePostRender) + +bool js_register_cc_Batcher2d(se::Object* obj) { + auto* cls = se::Class::create("Batcher2d", obj, nullptr, _SE(js_new_cc_Batcher2d)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("syncMeshBuffersToNative", _SE(js_cc_Batcher2d_syncMeshBuffersToNative)); + cls->defineFunction("initialize", _SE(js_cc_Batcher2d_initialize)); + cls->defineFunction("update", _SE(js_cc_Batcher2d_update)); + cls->defineFunction("uploadBuffers", _SE(js_cc_Batcher2d_uploadBuffers)); + cls->defineFunction("reset", _SE(js_cc_Batcher2d_reset)); + cls->defineFunction("syncRootNodesToNative", _SE(js_cc_Batcher2d_syncRootNodesToNative)); + cls->defineFunction("releaseDescriptorSetCache", _SE(js_cc_Batcher2d_releaseDescriptorSetCache)); + cls->defineFunction("getDefaultAttribute", _SE(js_cc_Batcher2d_getDefaultAttribute)); + cls->defineFunction("handlePostRender", _SE(js_cc_Batcher2d_handlePostRender)); + + + cls->defineStaticFunction("setSorting2DCount", _SE(js_cc_Batcher2d_setSorting2DCount_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Batcher2d)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Batcher2d_proto = cls->getProto(); + __jsb_cc_Batcher2d_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_native2d(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("n2d", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("n2d", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_MeshBufferLayout(ns); + js_register_cc_UIMeshBuffer(ns); + js_register_cc_Render2dLayout(ns); + js_register_cc_LocalDSBF(ns); + js_register_cc_RenderDrawInfo(ns); + js_register_cc_RenderEntity(ns); + js_register_cc_UIModelProxy(ns); + js_register_cc_RecordedRendererInfo(ns); + js_register_cc_Batcher2d(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_2d_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_2d_auto.h new file mode 100644 index 0000000000..af4a44937b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_2d_auto.h @@ -0,0 +1,109 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "2d/renderer/RenderDrawInfo.h" +#include "2d/renderer/UIMeshBuffer.h" +#include "2d/renderer/Batcher2d.h" +#include "2d/renderer/RenderEntity.h" +#include "2d/renderer/UIModelProxy.h" + + + +bool register_all_native2d(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::MeshBufferLayout); +extern se::Object *__jsb_cc_MeshBufferLayout_proto; // NOLINT +extern se::Class * __jsb_cc_MeshBufferLayout_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::MeshBufferLayout * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::UIMeshBuffer); +extern se::Object *__jsb_cc_UIMeshBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_UIMeshBuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Render2dLayout); +extern se::Object *__jsb_cc_Render2dLayout_proto; // NOLINT +extern se::Class * __jsb_cc_Render2dLayout_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Render2dLayout * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::LocalDSBF); +extern se::Object *__jsb_cc_LocalDSBF_proto; // NOLINT +extern se::Class * __jsb_cc_LocalDSBF_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::LocalDSBF * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderDrawInfo); +extern se::Object *__jsb_cc_RenderDrawInfo_proto; // NOLINT +extern se::Class * __jsb_cc_RenderDrawInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderEntity); +extern se::Object *__jsb_cc_RenderEntity_proto; // NOLINT +extern se::Class * __jsb_cc_RenderEntity_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::UIModelProxy); +extern se::Object *__jsb_cc_UIModelProxy_proto; // NOLINT +extern se::Class * __jsb_cc_UIModelProxy_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::RecordedRendererInfo); +extern se::Object *__jsb_cc_RecordedRendererInfo_proto; // NOLINT +extern se::Class * __jsb_cc_RecordedRendererInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::RecordedRendererInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Batcher2d); +extern se::Object *__jsb_cc_Batcher2d_proto; // NOLINT +extern se::Class * __jsb_cc_Batcher2d_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_assets_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_assets_auto.cpp new file mode 100644 index 0000000000..7c6f500241 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_assets_auto.cpp @@ -0,0 +1,27993 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "renderer/core/PassUtils.h" +#include "renderer/gfx-base/GFXDef-common.h" +#include "renderer/pipeline/Define.h" +#include "renderer/pipeline/RenderStage.h" +#include "scene/Pass.h" +#include "scene/RenderWindow.h" +#include "core/scene-graph/Scene.h" + + +#define cc_Asset__uuid_get(self_) self_->getUuid() +#define cc_Asset__uuid_set(self_, val_) self_->setUuid(val_) + + +#define cc_Asset_uuid_get(self_) self_->getUuid() + + +#define cc_Asset_nativeUrl_get(self_) self_->getNativeUrl() + + +#define cc_Asset__nativeDep_get(self_) self_->getNativeDep() + + +#define cc_Asset_isDefault_get(self_) self_->isDefault() + + +#define cc_ImageAsset_format_get(self_) self_->getFormat() +#define cc_ImageAsset_format_set(self_, val_) self_->setFormat(val_) + + +#define cc_ImageAsset_url_get(self_) self_->getUrl() +#define cc_ImageAsset_url_set(self_, val_) self_->setUrl(val_) + + +#define cc_BufferAsset__nativeAsset_get(self_) self_->getNativeAssetForJS() +#define cc_BufferAsset__nativeAsset_set(self_, val_) self_->setNativeAssetForJS(val_) + + +#define cc_TextureBase_isCompressed_get(self_) self_->isCompressed() + + +#define cc_TextureBase_isAlphaAtlas_get(self_) self_->isAlphaAtlas() + + +#define cc_TextureBase__width_get(self_) self_->getWidth() +#define cc_TextureBase__width_set(self_, val_) self_->setWidth(val_) + + +#define cc_TextureBase_width_get(self_) self_->getWidth() +#define cc_TextureBase_width_set(self_, val_) self_->setWidth(val_) + + +#define cc_TextureBase__height_get(self_) self_->getHeight() +#define cc_TextureBase__height_set(self_, val_) self_->setHeight(val_) + + +#define cc_TextureBase_height_get(self_) self_->getHeight() +#define cc_TextureBase_height_set(self_, val_) self_->setHeight(val_) + + +#define cc_SimpleTexture_mipmapLevel_get(self_) self_->mipmapLevel() + + +#define cc_RenderTexture_window_get(self_) self_->getWindow() + + +#define cc_Mesh__hash_get(self_) self_->getHash() +#define cc_Mesh__hash_set(self_, val_) self_->setHash(val_) + + +#define cc_Mesh_hash_get(self_) self_->getHash() + + +#define cc_Mesh_data_get(self_) self_->getData() + + +#define cc_Mesh__data_get(self_) self_->getData() + + +#define cc_Mesh_jointBufferIndices_get(self_) self_->getJointBufferIndices() + + +#define cc_Mesh_renderingSubMeshes_get(self_) self_->getRenderingSubMeshes() + + +#define cc_Mesh_subMeshCount_get(self_) self_->getSubMeshCount() + + +#define cc_Mesh__nativeAsset_get(self_) self_->getAssetData() +#define cc_Mesh__nativeAsset_set(self_, val_) self_->setAssetData(val_) + + +#define cc_Mesh__allowDataAccess_get(self_) self_->isAllowDataAccess() +#define cc_Mesh__allowDataAccess_set(self_, val_) self_->setAllowDataAccess(val_) + + +#define cc_Mesh_allowDataAccess_get(self_) self_->isAllowDataAccess() +#define cc_Mesh_allowDataAccess_set(self_, val_) self_->setAllowDataAccess(val_) + + +#define cc_Material_effectAsset_get(self_) self_->getEffectAsset() +#define cc_Material_effectAsset_set(self_, val_) self_->setEffectAsset(val_) + + +#define cc_Material_effectName_get(self_) self_->getEffectName() + + +#define cc_Material_technique_get(self_) self_->getTechniqueIndex() + + +#define cc_Material_hash_get(self_) self_->getHash() + + +#define cc_Material_parent_get(self_) self_->getParent() + + +#define cc_RenderingSubMesh_mesh_get(self_) self_->getMesh() +#define cc_RenderingSubMesh_mesh_set(self_, val_) self_->setMesh(val_) + + +#define cc_RenderingSubMesh_subMeshIdx_get(self_) self_->getSubMeshIdx() +#define cc_RenderingSubMesh_subMeshIdx_set(self_, val_) self_->setSubMeshIdx(val_) + + +#define cc_RenderingSubMesh_flatBuffers_get(self_) self_->getFlatBuffers() +#define cc_RenderingSubMesh_flatBuffers_set(self_, val_) self_->setFlatBuffers(val_) + + +#define cc_RenderingSubMesh__flatBuffers_get(self_) self_->getFlatBuffers() +#define cc_RenderingSubMesh__flatBuffers_set(self_, val_) self_->setFlatBuffers(val_) + + +#define cc_RenderingSubMesh_jointMappedBuffers_get(self_) self_->getJointMappedBuffers() + + +#define cc_RenderingSubMesh_iaInfo_get(self_) self_->getIaInfo() + + +#define cc_RenderingSubMesh__iaInfo_get(self_) self_->getIaInfo() + + +#define cc_RenderingSubMesh_primitiveMode_get(self_) self_->getPrimitiveMode() + + +#define cc_Skeleton_joints_get(self_) self_->getJoints() +#define cc_Skeleton_joints_set(self_, val_) self_->setJoints(val_) + + +#define cc_Skeleton__joints_get(self_) self_->getJoints() +#define cc_Skeleton__joints_set(self_, val_) self_->setJoints(val_) + + +#define cc_Skeleton_hash_get(self_) self_->getHash() +#define cc_Skeleton_hash_set(self_, val_) self_->setHash(val_) + + +#define cc_Skeleton__hash_get(self_) self_->getHash() +#define cc_Skeleton__hash_set(self_, val_) self_->setHash(val_) + + +#define cc_Skeleton__invBindposes_get(self_) self_->getInverseBindposes() + + +#define cc_Skeleton_inverseBindposes_get(self_) self_->getInverseBindposes() + + +#define cc_EffectAsset_techniques_get(self_) self_->getTechniques() +#define cc_EffectAsset_techniques_set(self_, val_) self_->setTechniques(val_) + + +#define cc_EffectAsset_shaders_get(self_) self_->getShaders() +#define cc_EffectAsset_shaders_set(self_, val_) self_->setShaders(val_) + + +#define cc_EffectAsset_combinations_get(self_) self_->getCombinations() +#define cc_EffectAsset_combinations_set(self_, val_) self_->setCombinations(val_) + + + +se::Class* __jsb_cc_Error_class = nullptr; +se::Object* __jsb_cc_Error_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Error) + +static bool js_cc_Error_msg_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Error *arg1 = (cc::Error *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->msg, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Error_msg_set) + +static bool js_cc_Error_msg_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Error *arg1 = (cc::Error *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->msg, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->msg, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Error_msg_get) + +static bool js_new_cc_Error(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Error *result; + result = (cc::Error *)new cc::Error(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Error, __jsb_cc_Error_class, js_delete_cc_Error) + +static bool js_delete_cc_Error(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Error) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Error * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("msg", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->msg), ctx); + } + + + return ok; +} + + +bool js_register_cc_Error(se::Object* obj) { + auto* cls = se::Class::create("Error", obj, nullptr, _SE(js_new_cc_Error)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("msg", _SE(js_cc_Error_msg_get), _SE(js_cc_Error_msg_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Error)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Error_proto = cls->getProto(); + __jsb_cc_Error_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BoundingBox_class = nullptr; +se::Object* __jsb_cc_BoundingBox_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BoundingBox) + +static bool js_cc_BoundingBox_min_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->min, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BoundingBox_min_set) + +static bool js_cc_BoundingBox_min_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->min, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->min, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BoundingBox_min_get) + +static bool js_cc_BoundingBox_max_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->max, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BoundingBox_max_set) + +static bool js_cc_BoundingBox_max_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BoundingBox *arg1 = (cc::BoundingBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->max, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->max, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BoundingBox_max_get) + +static bool js_new_cc_BoundingBox(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BoundingBox *result; + result = (cc::BoundingBox *)new cc::BoundingBox(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BoundingBox, __jsb_cc_BoundingBox_class, js_delete_cc_BoundingBox) + +static bool js_delete_cc_BoundingBox(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BoundingBox) + +template<> +bool sevalue_to_native(const se::Value &from, cc::BoundingBox * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("min", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->min), ctx); + } + + + json->getProperty("max", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->max), ctx); + } + + + return ok; +} + + +bool js_register_cc_BoundingBox(se::Object* obj) { + auto* cls = se::Class::create("BoundingBox", obj, nullptr, _SE(js_new_cc_BoundingBox)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("min", _SE(js_cc_BoundingBox_min_get), _SE(js_cc_BoundingBox_min_set)); + cls->defineProperty("max", _SE(js_cc_BoundingBox_max_get), _SE(js_cc_BoundingBox_max_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BoundingBox)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BoundingBox_proto = cls->getProto(); + __jsb_cc_BoundingBox_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_VertexIdChannel_class = nullptr; +se::Object* __jsb_cc_VertexIdChannel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_VertexIdChannel) + +static bool js_cc_VertexIdChannel_stream_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stream, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_VertexIdChannel_stream_set) + +static bool js_cc_VertexIdChannel_stream_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stream, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_VertexIdChannel_stream_get) + +static bool js_cc_VertexIdChannel_index_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->index, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_VertexIdChannel_index_set) + +static bool js_cc_VertexIdChannel_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::VertexIdChannel *arg1 = (cc::VertexIdChannel *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->index, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_VertexIdChannel_index_get) + +static bool js_new_cc_VertexIdChannel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::VertexIdChannel *result; + result = (cc::VertexIdChannel *)new cc::VertexIdChannel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_VertexIdChannel, __jsb_cc_VertexIdChannel_class, js_delete_cc_VertexIdChannel) + +static bool js_delete_cc_VertexIdChannel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_VertexIdChannel) + +template<> +bool sevalue_to_native(const se::Value &from, cc::VertexIdChannel * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("stream", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stream), ctx); + } + + + json->getProperty("index", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->index), ctx); + } + + + return ok; +} + + +bool js_register_cc_VertexIdChannel(se::Object* obj) { + auto* cls = se::Class::create("VertexIdChannel", obj, nullptr, _SE(js_new_cc_VertexIdChannel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("stream", _SE(js_cc_VertexIdChannel_stream_get), _SE(js_cc_VertexIdChannel_stream_set)); + cls->defineProperty("index", _SE(js_cc_VertexIdChannel_index_get), _SE(js_cc_VertexIdChannel_index_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_VertexIdChannel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_VertexIdChannel_proto = cls->getProto(); + __jsb_cc_VertexIdChannel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_NativeDep_class = nullptr; +se::Object* __jsb_cc_NativeDep_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_NativeDep) + +static bool js_cc_NativeDep_uuid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uuid, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_NativeDep_uuid_set) + +static bool js_cc_NativeDep_uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uuid, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uuid, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_NativeDep_uuid_get) + +static bool js_cc_NativeDep_ext_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ext, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_NativeDep_ext_set) + +static bool js_cc_NativeDep_ext_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ext, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ext, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_NativeDep_ext_get) + +static bool js_cc_NativeDep___isNative___set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->__isNative__); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_NativeDep___isNative___set) + +static bool js_cc_NativeDep___isNative___get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::NativeDep *arg1 = (cc::NativeDep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->__isNative__, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_NativeDep___isNative___get) + +static bool js_new_cc_NativeDep__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::NativeDep *result; + result = (cc::NativeDep *)new cc::NativeDep(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_NativeDep__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + bool arg1 ; + ccstd::string arg2 ; + ccstd::string arg3 ; + cc::NativeDep *result; + + ok &= sevalue_to_native(args[0], &arg1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::NativeDep *)new cc::NativeDep(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_NativeDep(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_NativeDep__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_NativeDep__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of NativeDep"); + return false; +} +SE_BIND_CTOR(js_new_cc_NativeDep, __jsb_cc_NativeDep_class, js_delete_cc_NativeDep) + +static bool js_cc_NativeDep_isValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::NativeDep *arg1 = (cc::NativeDep *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::NativeDep const *)arg1)->isValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_NativeDep_isValid) + +static bool js_delete_cc_NativeDep(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_NativeDep) + +template<> +bool sevalue_to_native(const se::Value &from, cc::NativeDep * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("uuid", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uuid), ctx); + } + + + json->getProperty("ext", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ext), ctx); + } + + + json->getProperty("__isNative__", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->__isNative__), ctx); + } + + + return ok; +} + + +bool js_register_cc_NativeDep(se::Object* obj) { + auto* cls = se::Class::create("NativeDep", obj, nullptr, _SE(js_new_cc_NativeDep)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("uuid", _SE(js_cc_NativeDep_uuid_get), _SE(js_cc_NativeDep_uuid_set)); + cls->defineProperty("ext", _SE(js_cc_NativeDep_ext_get), _SE(js_cc_NativeDep_ext_set)); + cls->defineProperty("__isNative__", _SE(js_cc_NativeDep___isNative___get), _SE(js_cc_NativeDep___isNative___set)); + + cls->defineFunction("isValid", _SE(js_cc_NativeDep_isValid)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_NativeDep)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_NativeDep_proto = cls->getProto(); + __jsb_cc_NativeDep_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IGeometryOptions_class = nullptr; +se::Object* __jsb_cc_IGeometryOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IGeometryOptions) + +static bool js_cc_IGeometryOptions_includeNormal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->includeNormal); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometryOptions_includeNormal_set) + +static bool js_cc_IGeometryOptions_includeNormal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->includeNormal, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometryOptions_includeNormal_get) + +static bool js_cc_IGeometryOptions_includeUV_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->includeUV); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometryOptions_includeUV_set) + +static bool js_cc_IGeometryOptions_includeUV_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometryOptions *arg1 = (cc::IGeometryOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->includeUV, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometryOptions_includeUV_get) + +static bool js_new_cc_IGeometryOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IGeometryOptions *result; + result = (cc::IGeometryOptions *)new cc::IGeometryOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IGeometryOptions, __jsb_cc_IGeometryOptions_class, js_delete_cc_IGeometryOptions) + +static bool js_delete_cc_IGeometryOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IGeometryOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometryOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("includeNormal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->includeNormal), ctx); + } + + + json->getProperty("includeUV", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->includeUV), ctx); + } + + + return ok; +} + + +bool js_register_cc_IGeometryOptions(se::Object* obj) { + auto* cls = se::Class::create("IGeometryOptions", obj, nullptr, _SE(js_new_cc_IGeometryOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("includeNormal", _SE(js_cc_IGeometryOptions_includeNormal_get), _SE(js_cc_IGeometryOptions_includeNormal_set)); + cls->defineProperty("includeUV", _SE(js_cc_IGeometryOptions_includeUV_get), _SE(js_cc_IGeometryOptions_includeUV_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IGeometryOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IGeometryOptions_proto = cls->getProto(); + __jsb_cc_IGeometryOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CustomAttribute_class = nullptr; +se::Object* __jsb_cc_CustomAttribute_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CustomAttribute) + +static bool js_cc_CustomAttribute_attr_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attr, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CustomAttribute_attr_set) + +static bool js_cc_CustomAttribute_attr_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attr, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attr, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CustomAttribute_attr_get) + +static bool js_cc_CustomAttribute_values_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->values, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CustomAttribute_values_set) + +static bool js_cc_CustomAttribute_values_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CustomAttribute *arg1 = (cc::CustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->values, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->values, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CustomAttribute_values_get) + +static bool js_new_cc_CustomAttribute(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::CustomAttribute *result; + result = (cc::CustomAttribute *)new cc::CustomAttribute(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CustomAttribute, __jsb_cc_CustomAttribute_class, js_delete_cc_CustomAttribute) + +static bool js_delete_cc_CustomAttribute(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CustomAttribute) + +template<> +bool sevalue_to_native(const se::Value &from, cc::CustomAttribute * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attr", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attr), ctx); + } + + + json->getProperty("values", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->values), ctx); + } + + + return ok; +} + + +bool js_register_cc_CustomAttribute(se::Object* obj) { + auto* cls = se::Class::create("CustomAttribute", obj, nullptr, _SE(js_new_cc_CustomAttribute)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attr", _SE(js_cc_CustomAttribute_attr_get), _SE(js_cc_CustomAttribute_attr_set)); + cls->defineProperty("values", _SE(js_cc_CustomAttribute_values_get), _SE(js_cc_CustomAttribute_values_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CustomAttribute)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CustomAttribute_proto = cls->getProto(); + __jsb_cc_CustomAttribute_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IGeometry_class = nullptr; +se::Object* __jsb_cc_IGeometry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IGeometry) + +static bool js_cc_IGeometry_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_positions_set) + +static bool js_cc_IGeometry_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_positions_get) + +static bool js_cc_IGeometry_normals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_normals_set) + +static bool js_cc_IGeometry_normals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_normals_get) + +static bool js_cc_IGeometry_uvs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uvs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_uvs_set) + +static bool js_cc_IGeometry_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uvs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uvs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_uvs_get) + +static bool js_cc_IGeometry_tangents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tangents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_tangents_set) + +static bool js_cc_IGeometry_tangents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tangents, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->tangents, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_tangents_get) + +static bool js_cc_IGeometry_colors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_colors_set) + +static bool js_cc_IGeometry_colors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_colors_get) + +static bool js_cc_IGeometry_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_attributes_set) + +static bool js_cc_IGeometry_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_attributes_get) + +static bool js_cc_IGeometry_customAttributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->customAttributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_customAttributes_set) + +static bool js_cc_IGeometry_customAttributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->customAttributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->customAttributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_customAttributes_get) + +static bool js_cc_IGeometry_boundingRadius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->boundingRadius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_boundingRadius_set) + +static bool js_cc_IGeometry_boundingRadius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->boundingRadius, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->boundingRadius, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_boundingRadius_get) + +static bool js_cc_IGeometry_minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_minPos_set) + +static bool js_cc_IGeometry_minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_minPos_get) + +static bool js_cc_IGeometry_maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_maxPos_set) + +static bool js_cc_IGeometry_maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_maxPos_get) + +static bool js_cc_IGeometry_indices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_indices_set) + +static bool js_cc_IGeometry_indices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_indices_get) + +static bool js_cc_IGeometry_primitiveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitiveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_primitiveMode_set) + +static bool js_cc_IGeometry_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitiveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitiveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_primitiveMode_get) + +static bool js_cc_IGeometry_doubleSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->doubleSided, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometry_doubleSided_set) + +static bool js_cc_IGeometry_doubleSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometry *arg1 = (cc::IGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->doubleSided, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->doubleSided, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometry_doubleSided_get) + +static bool js_new_cc_IGeometry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IGeometry *result; + result = (cc::IGeometry *)new cc::IGeometry(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IGeometry, __jsb_cc_IGeometry_class, js_delete_cc_IGeometry) + +static bool js_delete_cc_IGeometry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IGeometry) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometry * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("normals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normals), ctx); + } + + + json->getProperty("uvs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uvs), ctx); + } + + + json->getProperty("tangents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tangents), ctx); + } + + + json->getProperty("colors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colors), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("customAttributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->customAttributes), ctx); + } + + + json->getProperty("boundingRadius", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->boundingRadius), ctx); + } + + + json->getProperty("minPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minPos), ctx); + } + + + json->getProperty("maxPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxPos), ctx); + } + + + json->getProperty("indices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices), ctx); + } + + + json->getProperty("primitiveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitiveMode), ctx); + } + + + json->getProperty("doubleSided", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->doubleSided), ctx); + } + + + return ok; +} + + +bool js_register_cc_IGeometry(se::Object* obj) { + auto* cls = se::Class::create("IGeometry", obj, nullptr, _SE(js_new_cc_IGeometry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("positions", _SE(js_cc_IGeometry_positions_get), _SE(js_cc_IGeometry_positions_set)); + cls->defineProperty("normals", _SE(js_cc_IGeometry_normals_get), _SE(js_cc_IGeometry_normals_set)); + cls->defineProperty("uvs", _SE(js_cc_IGeometry_uvs_get), _SE(js_cc_IGeometry_uvs_set)); + cls->defineProperty("tangents", _SE(js_cc_IGeometry_tangents_get), _SE(js_cc_IGeometry_tangents_set)); + cls->defineProperty("colors", _SE(js_cc_IGeometry_colors_get), _SE(js_cc_IGeometry_colors_set)); + cls->defineProperty("attributes", _SE(js_cc_IGeometry_attributes_get), _SE(js_cc_IGeometry_attributes_set)); + cls->defineProperty("customAttributes", _SE(js_cc_IGeometry_customAttributes_get), _SE(js_cc_IGeometry_customAttributes_set)); + cls->defineProperty("boundingRadius", _SE(js_cc_IGeometry_boundingRadius_get), _SE(js_cc_IGeometry_boundingRadius_set)); + cls->defineProperty("minPos", _SE(js_cc_IGeometry_minPos_get), _SE(js_cc_IGeometry_minPos_set)); + cls->defineProperty("maxPos", _SE(js_cc_IGeometry_maxPos_get), _SE(js_cc_IGeometry_maxPos_set)); + cls->defineProperty("indices", _SE(js_cc_IGeometry_indices_get), _SE(js_cc_IGeometry_indices_set)); + cls->defineProperty("primitiveMode", _SE(js_cc_IGeometry_primitiveMode_get), _SE(js_cc_IGeometry_primitiveMode_set)); + cls->defineProperty("doubleSided", _SE(js_cc_IGeometry_doubleSided_get), _SE(js_cc_IGeometry_doubleSided_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IGeometry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IGeometry_proto = cls->getProto(); + __jsb_cc_IGeometry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_DynamicCustomAttribute_class = nullptr; +se::Object* __jsb_cc_DynamicCustomAttribute_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DynamicCustomAttribute) + +static bool js_cc_DynamicCustomAttribute_attr_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attr, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DynamicCustomAttribute_attr_set) + +static bool js_cc_DynamicCustomAttribute_attr_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attr, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attr, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DynamicCustomAttribute_attr_get) + +static bool js_cc_DynamicCustomAttribute_values_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->values, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DynamicCustomAttribute_values_set) + +static bool js_cc_DynamicCustomAttribute_values_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DynamicCustomAttribute *arg1 = (cc::DynamicCustomAttribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->values, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->values, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DynamicCustomAttribute_values_get) + +static bool js_new_cc_DynamicCustomAttribute(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DynamicCustomAttribute *result; + result = (cc::DynamicCustomAttribute *)new cc::DynamicCustomAttribute(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DynamicCustomAttribute, __jsb_cc_DynamicCustomAttribute_class, js_delete_cc_DynamicCustomAttribute) + +static bool js_delete_cc_DynamicCustomAttribute(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DynamicCustomAttribute) + +template<> +bool sevalue_to_native(const se::Value &from, cc::DynamicCustomAttribute * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attr", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attr), ctx); + } + + + json->getProperty("values", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->values), ctx); + } + + + return ok; +} + + +bool js_register_cc_DynamicCustomAttribute(se::Object* obj) { + auto* cls = se::Class::create("DynamicCustomAttribute", obj, nullptr, _SE(js_new_cc_DynamicCustomAttribute)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attr", _SE(js_cc_DynamicCustomAttribute_attr_get), _SE(js_cc_DynamicCustomAttribute_attr_set)); + cls->defineProperty("values", _SE(js_cc_DynamicCustomAttribute_values_get), _SE(js_cc_DynamicCustomAttribute_values_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DynamicCustomAttribute)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DynamicCustomAttribute_proto = cls->getProto(); + __jsb_cc_DynamicCustomAttribute_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDynamicGeometry_class = nullptr; +se::Object* __jsb_cc_IDynamicGeometry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDynamicGeometry) + +static bool js_cc_IDynamicGeometry_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_positions_set) + +static bool js_cc_IDynamicGeometry_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_positions_get) + +static bool js_cc_IDynamicGeometry_normals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_normals_set) + +static bool js_cc_IDynamicGeometry_normals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_normals_get) + +static bool js_cc_IDynamicGeometry_uvs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uvs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_uvs_set) + +static bool js_cc_IDynamicGeometry_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uvs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uvs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_uvs_get) + +static bool js_cc_IDynamicGeometry_tangents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tangents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_tangents_set) + +static bool js_cc_IDynamicGeometry_tangents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tangents, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->tangents, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_tangents_get) + +static bool js_cc_IDynamicGeometry_colors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_colors_set) + +static bool js_cc_IDynamicGeometry_colors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_colors_get) + +static bool js_cc_IDynamicGeometry_customAttributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->customAttributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_customAttributes_set) + +static bool js_cc_IDynamicGeometry_customAttributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->customAttributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->customAttributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_customAttributes_get) + +static bool js_cc_IDynamicGeometry_minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_minPos_set) + +static bool js_cc_IDynamicGeometry_minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_minPos_get) + +static bool js_cc_IDynamicGeometry_maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_maxPos_set) + +static bool js_cc_IDynamicGeometry_maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_maxPos_get) + +static bool js_cc_IDynamicGeometry_indices16_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices16, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_indices16_set) + +static bool js_cc_IDynamicGeometry_indices16_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices16, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices16, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_indices16_get) + +static bool js_cc_IDynamicGeometry_indices32_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices32, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_indices32_set) + +static bool js_cc_IDynamicGeometry_indices32_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices32, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices32, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_indices32_get) + +static bool js_cc_IDynamicGeometry_primitiveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitiveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_primitiveMode_set) + +static bool js_cc_IDynamicGeometry_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitiveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitiveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_primitiveMode_get) + +static bool js_cc_IDynamicGeometry_doubleSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->doubleSided, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDynamicGeometry_doubleSided_set) + +static bool js_cc_IDynamicGeometry_doubleSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDynamicGeometry *arg1 = (cc::IDynamicGeometry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->doubleSided, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->doubleSided, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDynamicGeometry_doubleSided_get) + +static bool js_new_cc_IDynamicGeometry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDynamicGeometry *result; + result = (cc::IDynamicGeometry *)new cc::IDynamicGeometry(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDynamicGeometry, __jsb_cc_IDynamicGeometry_class, js_delete_cc_IDynamicGeometry) + +static bool js_delete_cc_IDynamicGeometry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDynamicGeometry) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDynamicGeometry * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("normals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normals), ctx); + } + + + json->getProperty("uvs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uvs), ctx); + } + + + json->getProperty("tangents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tangents), ctx); + } + + + json->getProperty("colors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colors), ctx); + } + + + json->getProperty("customAttributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->customAttributes), ctx); + } + + + json->getProperty("minPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minPos), ctx); + } + + + json->getProperty("maxPos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxPos), ctx); + } + + + json->getProperty("indices16", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices16), ctx); + } + + + json->getProperty("indices32", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices32), ctx); + } + + + json->getProperty("primitiveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitiveMode), ctx); + } + + + json->getProperty("doubleSided", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->doubleSided), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDynamicGeometry(se::Object* obj) { + auto* cls = se::Class::create("IDynamicGeometry", obj, nullptr, _SE(js_new_cc_IDynamicGeometry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("positions", _SE(js_cc_IDynamicGeometry_positions_get), _SE(js_cc_IDynamicGeometry_positions_set)); + cls->defineProperty("normals", _SE(js_cc_IDynamicGeometry_normals_get), _SE(js_cc_IDynamicGeometry_normals_set)); + cls->defineProperty("uvs", _SE(js_cc_IDynamicGeometry_uvs_get), _SE(js_cc_IDynamicGeometry_uvs_set)); + cls->defineProperty("tangents", _SE(js_cc_IDynamicGeometry_tangents_get), _SE(js_cc_IDynamicGeometry_tangents_set)); + cls->defineProperty("colors", _SE(js_cc_IDynamicGeometry_colors_get), _SE(js_cc_IDynamicGeometry_colors_set)); + cls->defineProperty("customAttributes", _SE(js_cc_IDynamicGeometry_customAttributes_get), _SE(js_cc_IDynamicGeometry_customAttributes_set)); + cls->defineProperty("minPos", _SE(js_cc_IDynamicGeometry_minPos_get), _SE(js_cc_IDynamicGeometry_minPos_set)); + cls->defineProperty("maxPos", _SE(js_cc_IDynamicGeometry_maxPos_get), _SE(js_cc_IDynamicGeometry_maxPos_set)); + cls->defineProperty("indices16", _SE(js_cc_IDynamicGeometry_indices16_get), _SE(js_cc_IDynamicGeometry_indices16_set)); + cls->defineProperty("indices32", _SE(js_cc_IDynamicGeometry_indices32_get), _SE(js_cc_IDynamicGeometry_indices32_set)); + cls->defineProperty("primitiveMode", _SE(js_cc_IDynamicGeometry_primitiveMode_get), _SE(js_cc_IDynamicGeometry_primitiveMode_set)); + cls->defineProperty("doubleSided", _SE(js_cc_IDynamicGeometry_doubleSided_get), _SE(js_cc_IDynamicGeometry_doubleSided_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDynamicGeometry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDynamicGeometry_proto = cls->getProto(); + __jsb_cc_IDynamicGeometry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Asset_class = nullptr; +se::Object* __jsb_cc_Asset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Asset) + +static bool js_new_cc_Asset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Asset *result; + result = (cc::Asset *)new cc::Asset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Asset, __jsb_cc_Asset_class, js_delete_cc_Asset) + +static bool js_delete_cc_Asset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Asset) + +static bool js_cc_Asset_getNativeAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Asset const *)arg1)->getNativeAsset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_getNativeAsset) + +static bool js_cc_Asset_setNativeAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any *arg2 = 0 ; + ccstd::any temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setNativeAsset((ccstd::any const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_setNativeAsset) + +static bool js_cc_Asset_addAssetRef(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->addAssetRef(); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_addAssetRef) + +static bool js_cc_Asset_decAssetRef__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->decAssetRef(arg2); + + + return true; +} + +static bool js_cc_Asset_decAssetRef__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->decAssetRef(); + + + return true; +} + +static bool js_cc_Asset_decAssetRef(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Asset_decAssetRef__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Asset_decAssetRef__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Asset_decAssetRef) + +static bool js_cc_Asset_getAssetRefCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Asset const *)arg1)->getAssetRefCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_getAssetRefCount) + +static bool js_cc_Asset_onLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onLoaded(); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_onLoaded) + +static bool js_cc_Asset_initDefault__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initDefault(); + + + return true; +} + +static bool js_cc_Asset_initDefault__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::optional< ccstd::string > *arg2 = 0 ; + ccstd::optional< ccstd::string > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initDefault((ccstd::optional< ccstd::string > const &)*arg2); + + + return true; +} + +static bool js_cc_Asset_initDefault(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_Asset_initDefault__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Asset_initDefault__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Asset_initDefault) + +static bool js_cc_Asset_validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Asset const *)arg1)->validate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_validate) + +static bool js_cc_Asset_serialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any *arg2 = 0 ; + ccstd::any temp2 ; + ccstd::any result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->serialize((ccstd::any const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_serialize) + +static bool js_cc_Asset_deserialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::any *arg2 = 0 ; + ccstd::any *arg3 = 0 ; + ccstd::any temp2 ; + ccstd::any temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->deserialize((ccstd::any const &)*arg2,(ccstd::any const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Asset_deserialize) + +static bool js_cc_Asset__native_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_native, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Asset__native_set) + +static bool js_cc_Asset__native_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_native, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_native, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Asset__native_get) + +static bool js_cc_Asset__nativeUrl_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_nativeUrl, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Asset__nativeUrl_set) + +static bool js_cc_Asset__nativeUrl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_nativeUrl, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_nativeUrl, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Asset__nativeUrl_get) + +static bool js_cc_Asset__uuid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Asset__uuid_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Asset__uuid_set) + +static bool js_cc_Asset__uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_Asset__uuid_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_Asset__uuid_get) + +static bool js_cc_Asset_uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_Asset_uuid_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_Asset_uuid_get) + +static bool js_cc_Asset_nativeUrl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + ccstd::string result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Asset_nativeUrl_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_Asset_nativeUrl_get) + +static bool js_cc_Asset__nativeDep_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + cc::NativeDep result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Asset__nativeDep_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_Asset__nativeDep_get) + +static bool js_cc_Asset_isDefault_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Asset *arg1 = (cc::Asset *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Asset_isDefault_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Asset_isDefault_get) + +bool js_register_cc_Asset(se::Object* obj) { + auto* cls = se::Class::create("Asset", obj, __jsb_cc_CCObject_proto, _SE(js_new_cc_Asset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_native", _SE(js_cc_Asset__native_get), _SE(js_cc_Asset__native_set)); + cls->defineProperty("_nativeUrl", _SE(js_cc_Asset__nativeUrl_get), _SE(js_cc_Asset__nativeUrl_set)); + cls->defineProperty("_uuid", _SE(js_cc_Asset__uuid_get), _SE(js_cc_Asset__uuid_set)); + cls->defineProperty("uuid", _SE(js_cc_Asset_uuid_get), nullptr); + cls->defineProperty("nativeUrl", _SE(js_cc_Asset_nativeUrl_get), nullptr); + cls->defineProperty("_nativeDep", _SE(js_cc_Asset__nativeDep_get), nullptr); + cls->defineProperty("isDefault", _SE(js_cc_Asset_isDefault_get), nullptr); + + cls->defineFunction("getNativeAsset", _SE(js_cc_Asset_getNativeAsset)); + cls->defineFunction("setNativeAsset", _SE(js_cc_Asset_setNativeAsset)); + cls->defineFunction("addAssetRef", _SE(js_cc_Asset_addAssetRef)); + cls->defineFunction("decAssetRef", _SE(js_cc_Asset_decAssetRef)); + cls->defineFunction("getAssetRefCount", _SE(js_cc_Asset_getAssetRefCount)); + cls->defineFunction("onLoaded", _SE(js_cc_Asset_onLoaded)); + cls->defineFunction("initDefault", _SE(js_cc_Asset_initDefault)); + cls->defineFunction("validate", _SE(js_cc_Asset_validate)); + cls->defineFunction("serialize", _SE(js_cc_Asset_serialize)); + cls->defineFunction("deserialize", _SE(js_cc_Asset_deserialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Asset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Asset_proto = cls->getProto(); + __jsb_cc_Asset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureBase_class = nullptr; +se::Object* __jsb_cc_TextureBase_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureBase) + +static bool js_new_cc_TextureBase(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureBase *result; + result = (cc::TextureBase *)new cc::TextureBase(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureBase, __jsb_cc_TextureBase_class, js_delete_cc_TextureBase) + +static bool js_delete_cc_TextureBase(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureBase) + +static bool js_cc_TextureBase_getId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + ccstd::string *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(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &((cc::TextureBase const *)arg1)->getId(); + + 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_TextureBase_getId) + +static bool js_cc_TextureBase_getPixelFormat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::PixelFormat result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureBase::PixelFormat)((cc::TextureBase const *)arg1)->getPixelFormat(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_getPixelFormat) + +static bool js_cc_TextureBase_getAnisotropy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::TextureBase const *)arg1)->getAnisotropy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_getAnisotropy) + +static bool js_cc_TextureBase_setWrapMode__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::WrapMode arg2 ; + cc::TextureBase::WrapMode arg3 ; + cc::TextureBase::WrapMode arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setWrapMode(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_TextureBase_setWrapMode__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::WrapMode arg2 ; + cc::TextureBase::WrapMode arg3 ; + + arg1 = SE_THIS_OBJECT(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)->setWrapMode(arg2,arg3); + + + return true; +} + +static bool js_cc_TextureBase_setWrapMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_TextureBase_setWrapMode__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_TextureBase_setWrapMode__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_TextureBase_setWrapMode) + +static bool js_cc_TextureBase_setFilters(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::Filter arg2 ; + cc::TextureBase::Filter arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFilters(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_setFilters) + +static bool js_cc_TextureBase_setMipFilter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::TextureBase::Filter arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMipFilter(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_setMipFilter) + +static bool js_cc_TextureBase_setAnisotropy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setAnisotropy(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_setAnisotropy) + +static bool js_cc_TextureBase_getHash(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + ccstd::hash_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::TextureBase const *)arg1)->getHash(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureBase_getHash) + +static bool js_cc_TextureBase_getGFXTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::gfx::Texture *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)((cc::TextureBase const *)arg1)->getGFXTexture(); + + 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_TextureBase_getGFXTexture) + +static bool js_cc_TextureBase_getSamplerInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::gfx::SamplerInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SamplerInfo *) &((cc::TextureBase const *)arg1)->getSamplerInfo(); + + 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_TextureBase_getSamplerInfo) + +static bool js_cc_TextureBase_getGFXSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::TextureBase const *)arg1)->getGFXSampler(); + + 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_TextureBase_getGFXSampler) + +static bool js_cc_TextureBase__format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__format_set) + +static bool js_cc_TextureBase__format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__format_get) + +static bool js_cc_TextureBase__minFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_minFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__minFilter_set) + +static bool js_cc_TextureBase__minFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_minFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_minFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__minFilter_get) + +static bool js_cc_TextureBase__magFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_magFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__magFilter_set) + +static bool js_cc_TextureBase__magFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_magFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_magFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__magFilter_get) + +static bool js_cc_TextureBase__mipFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_mipFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__mipFilter_set) + +static bool js_cc_TextureBase__mipFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_mipFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_mipFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__mipFilter_get) + +static bool js_cc_TextureBase__wrapS_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_wrapS, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__wrapS_set) + +static bool js_cc_TextureBase__wrapS_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_wrapS, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_wrapS, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__wrapS_get) + +static bool js_cc_TextureBase__wrapT_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_wrapT, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__wrapT_set) + +static bool js_cc_TextureBase__wrapT_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_wrapT, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_wrapT, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__wrapT_get) + +static bool js_cc_TextureBase__wrapR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_wrapR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__wrapR_set) + +static bool js_cc_TextureBase__wrapR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_wrapR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_wrapR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__wrapR_get) + +static bool js_cc_TextureBase__anisotropy_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_anisotropy, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__anisotropy_set) + +static bool js_cc_TextureBase__anisotropy_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_anisotropy, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__anisotropy_get) + +static bool js_cc_TextureBase_isCompressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_TextureBase_isCompressed_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_isCompressed_get) + +static bool js_cc_TextureBase_isAlphaAtlas_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_TextureBase_isAlphaAtlas_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_isAlphaAtlas_get) + +static bool js_cc_TextureBase__width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase__width_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__width_set) + +static bool js_cc_TextureBase__width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase__width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__width_get) + +static bool js_cc_TextureBase_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase_width_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase_width_set) + +static bool js_cc_TextureBase_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_width_get) + +static bool js_cc_TextureBase__height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase__height_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase__height_set) + +static bool js_cc_TextureBase__height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase__height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase__height_get) + +static bool js_cc_TextureBase_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_TextureBase_height_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureBase_height_set) + +static bool js_cc_TextureBase_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureBase *arg1 = (cc::TextureBase *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_TextureBase_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureBase_height_get) + +bool js_register_cc_TextureBase(se::Object* obj) { + auto* cls = se::Class::create("TextureBase", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_TextureBase)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_format", _SE(js_cc_TextureBase__format_get), _SE(js_cc_TextureBase__format_set)); + cls->defineProperty("_minFilter", _SE(js_cc_TextureBase__minFilter_get), _SE(js_cc_TextureBase__minFilter_set)); + cls->defineProperty("_magFilter", _SE(js_cc_TextureBase__magFilter_get), _SE(js_cc_TextureBase__magFilter_set)); + cls->defineProperty("_mipFilter", _SE(js_cc_TextureBase__mipFilter_get), _SE(js_cc_TextureBase__mipFilter_set)); + cls->defineProperty("_wrapS", _SE(js_cc_TextureBase__wrapS_get), _SE(js_cc_TextureBase__wrapS_set)); + cls->defineProperty("_wrapT", _SE(js_cc_TextureBase__wrapT_get), _SE(js_cc_TextureBase__wrapT_set)); + cls->defineProperty("_wrapR", _SE(js_cc_TextureBase__wrapR_get), _SE(js_cc_TextureBase__wrapR_set)); + cls->defineProperty("_anisotropy", _SE(js_cc_TextureBase__anisotropy_get), _SE(js_cc_TextureBase__anisotropy_set)); + cls->defineProperty("isCompressed", _SE(js_cc_TextureBase_isCompressed_get), nullptr); + cls->defineProperty("isAlphaAtlas", _SE(js_cc_TextureBase_isAlphaAtlas_get), nullptr); + cls->defineProperty("_width", _SE(js_cc_TextureBase__width_get), _SE(js_cc_TextureBase__width_set)); + cls->defineProperty("width", _SE(js_cc_TextureBase_width_get), _SE(js_cc_TextureBase_width_set)); + cls->defineProperty("_height", _SE(js_cc_TextureBase__height_get), _SE(js_cc_TextureBase__height_set)); + cls->defineProperty("height", _SE(js_cc_TextureBase_height_get), _SE(js_cc_TextureBase_height_set)); + + cls->defineFunction("getId", _SE(js_cc_TextureBase_getId)); + cls->defineFunction("getPixelFormat", _SE(js_cc_TextureBase_getPixelFormat)); + cls->defineFunction("getAnisotropy", _SE(js_cc_TextureBase_getAnisotropy)); + cls->defineFunction("setWrapMode", _SE(js_cc_TextureBase_setWrapMode)); + cls->defineFunction("setFilters", _SE(js_cc_TextureBase_setFilters)); + cls->defineFunction("setMipFilter", _SE(js_cc_TextureBase_setMipFilter)); + cls->defineFunction("setAnisotropy", _SE(js_cc_TextureBase_setAnisotropy)); + cls->defineFunction("getHash", _SE(js_cc_TextureBase_getHash)); + cls->defineFunction("getGFXTexture", _SE(js_cc_TextureBase_getGFXTexture)); + cls->defineFunction("getSamplerInfo", _SE(js_cc_TextureBase_getSamplerInfo)); + cls->defineFunction("getGFXSampler", _SE(js_cc_TextureBase_getGFXSampler)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureBase)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureBase_proto = cls->getProto(); + __jsb_cc_TextureBase_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SimpleTexture_class = nullptr; +se::Object* __jsb_cc_SimpleTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SimpleTexture) + +static bool js_delete_cc_SimpleTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SimpleTexture) + +static bool js_cc_SimpleTexture_updateImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateImage(); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_updateImage) + +static bool js_cc_SimpleTexture_updateMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateMipmaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_updateMipmaps) + +static bool js_cc_SimpleTexture_uploadData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + uint32_t arg3 ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->uploadData((uint8_t const *)arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SimpleTexture_uploadData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->uploadData((uint8_t const *)arg2,arg3); + + + return true; +} + +static bool js_cc_SimpleTexture_uploadData__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint8_t *arg2 = (uint8_t *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->uploadData((uint8_t const *)arg2); + + + return true; +} + +static bool js_cc_SimpleTexture_uploadData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SimpleTexture_uploadData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SimpleTexture_uploadData__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SimpleTexture_uploadData__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SimpleTexture_uploadData) + +static bool js_cc_SimpleTexture_assignImage__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + cc::ImageAsset *arg2 = (cc::ImageAsset *) NULL ; + uint32_t arg3 ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->assignImage(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SimpleTexture_assignImage__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + cc::ImageAsset *arg2 = (cc::ImageAsset *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->assignImage(arg2,arg3); + + + return true; +} + +static bool js_cc_SimpleTexture_assignImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SimpleTexture_assignImage__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SimpleTexture_assignImage__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SimpleTexture_assignImage) + +static bool js_cc_SimpleTexture_checkTextureLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->checkTextureLoaded(); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_checkTextureLoaded) + +static bool js_cc_SimpleTexture_setMipmapLevel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMipmapLevel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_setMipmapLevel) + +static bool js_cc_SimpleTexture_setMipRange(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipRange(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_setMipRange) + +static bool js_cc_SimpleTexture_isUsingOfflineMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isUsingOfflineMipmaps(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SimpleTexture_isUsingOfflineMipmaps) + +static bool js_cc_SimpleTexture_mipmapLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SimpleTexture *arg1 = (cc::SimpleTexture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_SimpleTexture_mipmapLevel_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_SimpleTexture_mipmapLevel_get) + +bool js_register_cc_SimpleTexture(se::Object* obj) { + auto* cls = se::Class::create("SimpleTexture", obj, __jsb_cc_TextureBase_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mipmapLevel", _SE(js_cc_SimpleTexture_mipmapLevel_get), nullptr); + + cls->defineFunction("updateImage", _SE(js_cc_SimpleTexture_updateImage)); + cls->defineFunction("updateMipmaps", _SE(js_cc_SimpleTexture_updateMipmaps)); + cls->defineFunction("uploadData", _SE(js_cc_SimpleTexture_uploadData)); + cls->defineFunction("assignImage", _SE(js_cc_SimpleTexture_assignImage)); + cls->defineFunction("checkTextureLoaded", _SE(js_cc_SimpleTexture_checkTextureLoaded)); + cls->defineFunction("setMipmapLevel", _SE(js_cc_SimpleTexture_setMipmapLevel)); + cls->defineFunction("setMipRange", _SE(js_cc_SimpleTexture_setMipRange)); + cls->defineFunction("isUsingOfflineMipmaps", _SE(js_cc_SimpleTexture_isUsingOfflineMipmaps)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SimpleTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SimpleTexture_proto = cls->getProto(); + __jsb_cc_SimpleTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITexture2DSerializeData_class = nullptr; +se::Object* __jsb_cc_ITexture2DSerializeData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITexture2DSerializeData) + +static bool js_cc_ITexture2DSerializeData_base_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->base, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DSerializeData_base_set) + +static bool js_cc_ITexture2DSerializeData_base_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->base, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->base, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DSerializeData_base_get) + +static bool js_cc_ITexture2DSerializeData_mipmaps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmaps, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DSerializeData_mipmaps_set) + +static bool js_cc_ITexture2DSerializeData_mipmaps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DSerializeData *arg1 = (cc::ITexture2DSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmaps, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmaps, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DSerializeData_mipmaps_get) + +static bool js_new_cc_ITexture2DSerializeData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITexture2DSerializeData *result; + result = (cc::ITexture2DSerializeData *)new cc::ITexture2DSerializeData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITexture2DSerializeData, __jsb_cc_ITexture2DSerializeData_class, js_delete_cc_ITexture2DSerializeData) + +static bool js_delete_cc_ITexture2DSerializeData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITexture2DSerializeData) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DSerializeData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("base", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->base), ctx); + } + + + json->getProperty("mipmaps", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmaps), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITexture2DSerializeData(se::Object* obj) { + auto* cls = se::Class::create("ITexture2DSerializeData", obj, nullptr, _SE(js_new_cc_ITexture2DSerializeData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("base", _SE(js_cc_ITexture2DSerializeData_base_get), _SE(js_cc_ITexture2DSerializeData_base_set)); + cls->defineProperty("mipmaps", _SE(js_cc_ITexture2DSerializeData_mipmaps_get), _SE(js_cc_ITexture2DSerializeData_mipmaps_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITexture2DSerializeData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITexture2DSerializeData_proto = cls->getProto(); + __jsb_cc_ITexture2DSerializeData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITexture2DCreateInfo_class = nullptr; +se::Object* __jsb_cc_ITexture2DCreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITexture2DCreateInfo) + +static bool js_cc_ITexture2DCreateInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_width_set) + +static bool js_cc_ITexture2DCreateInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_width_get) + +static bool js_cc_ITexture2DCreateInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_height_set) + +static bool js_cc_ITexture2DCreateInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_height_get) + +static bool js_cc_ITexture2DCreateInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_format_set) + +static bool js_cc_ITexture2DCreateInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_format_get) + +static bool js_cc_ITexture2DCreateInfo_mipmapLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_mipmapLevel_set) + +static bool js_cc_ITexture2DCreateInfo_mipmapLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapLevel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapLevel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_mipmapLevel_get) + +static bool js_cc_ITexture2DCreateInfo_baseLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_baseLevel_set) + +static bool js_cc_ITexture2DCreateInfo_baseLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseLevel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->baseLevel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_baseLevel_get) + +static bool js_cc_ITexture2DCreateInfo_maxLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITexture2DCreateInfo_maxLevel_set) + +static bool js_cc_ITexture2DCreateInfo_maxLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITexture2DCreateInfo *arg1 = (cc::ITexture2DCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxLevel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxLevel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITexture2DCreateInfo_maxLevel_get) + +static bool js_new_cc_ITexture2DCreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITexture2DCreateInfo *result; + result = (cc::ITexture2DCreateInfo *)new cc::ITexture2DCreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITexture2DCreateInfo, __jsb_cc_ITexture2DCreateInfo_class, js_delete_cc_ITexture2DCreateInfo) + +static bool js_delete_cc_ITexture2DCreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITexture2DCreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DCreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("mipmapLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapLevel), ctx); + } + + + json->getProperty("baseLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseLevel), ctx); + } + + + json->getProperty("maxLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxLevel), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITexture2DCreateInfo(se::Object* obj) { + auto* cls = se::Class::create("ITexture2DCreateInfo", obj, nullptr, _SE(js_new_cc_ITexture2DCreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_ITexture2DCreateInfo_width_get), _SE(js_cc_ITexture2DCreateInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_ITexture2DCreateInfo_height_get), _SE(js_cc_ITexture2DCreateInfo_height_set)); + cls->defineProperty("format", _SE(js_cc_ITexture2DCreateInfo_format_get), _SE(js_cc_ITexture2DCreateInfo_format_set)); + cls->defineProperty("mipmapLevel", _SE(js_cc_ITexture2DCreateInfo_mipmapLevel_get), _SE(js_cc_ITexture2DCreateInfo_mipmapLevel_set)); + cls->defineProperty("baseLevel", _SE(js_cc_ITexture2DCreateInfo_baseLevel_get), _SE(js_cc_ITexture2DCreateInfo_baseLevel_set)); + cls->defineProperty("maxLevel", _SE(js_cc_ITexture2DCreateInfo_maxLevel_get), _SE(js_cc_ITexture2DCreateInfo_maxLevel_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITexture2DCreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITexture2DCreateInfo_proto = cls->getProto(); + __jsb_cc_ITexture2DCreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Texture2D_class = nullptr; +se::Object* __jsb_cc_Texture2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Texture2D) + +static bool js_new_cc_Texture2D(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Texture2D *result; + result = (cc::Texture2D *)new cc::Texture2D(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Texture2D, __jsb_cc_Texture2D_class, js_delete_cc_Texture2D) + +static bool js_delete_cc_Texture2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Texture2D) + +static bool js_cc_Texture2D_getMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *) &((cc::Texture2D const *)arg1)->getMipmaps(); + + 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_Texture2D_getMipmaps) + +static bool js_cc_Texture2D_getMipmapsUuids(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< ccstd::string > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &((cc::Texture2D const *)arg1)->getMipmapsUuids(); + + 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_Texture2D_getMipmapsUuids) + +static bool js_cc_Texture2D_syncMipmapsForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->syncMipmapsForJS((ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_syncMipmapsForJS) + +static bool js_cc_Texture2D_setMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmaps((ccstd::vector< cc::IntrusivePtr< cc::ImageAsset > > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_setMipmaps) + +static bool js_cc_Texture2D_getImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::ImageAsset *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(s); + if (nullptr == arg1) return true; + result = (cc::ImageAsset *)((cc::Texture2D const *)arg1)->getImage(); + + 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_Texture2D_getImage) + +static bool js_cc_Texture2D_setImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::ImageAsset *arg2 = (cc::ImageAsset *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setImage(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_setImage) + +static bool js_cc_Texture2D_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_initialize) + +static bool js_cc_Texture2D_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::ITexture2DCreateInfo *arg2 = 0 ; + cc::ITexture2DCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::ITexture2DCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_reset) + +static bool js_cc_Texture2D_create__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->create(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->create(arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + uint32_t arg5 ; + + arg1 = SE_THIS_OBJECT(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)->create(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::TextureBase::PixelFormat arg4 ; + + arg1 = SE_THIS_OBJECT(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)->create(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Texture2D_create__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->create(arg2,arg3); + + + return true; +} + +static bool js_cc_Texture2D_create(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_Texture2D_create__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_Texture2D_create__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Texture2D_create__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_Texture2D_create__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Texture2D_create__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Texture2D_create) + +static bool js_cc_Texture2D_description(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Texture2D const *)arg1)->description(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_description) + +static bool js_cc_Texture2D_releaseTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->releaseTexture(); + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_releaseTexture) + +static bool js_cc_Texture2D_getGfxTextureCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::gfx::TextureUsageBit arg2 ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + cc::gfx::TextureFlagBit arg5 ; + cc::gfx::TextureInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_getGfxTextureCreateInfo) + +static bool js_cc_Texture2D_getGfxTextureViewCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Texture2D *arg1 = (cc::Texture2D *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::gfx::TextureViewInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureViewCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Texture2D_getGfxTextureViewCreateInfo) + +bool js_register_cc_Texture2D(se::Object* obj) { + auto* cls = se::Class::create("Texture2D", obj, __jsb_cc_SimpleTexture_proto, _SE(js_new_cc_Texture2D)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getMipmaps", _SE(js_cc_Texture2D_getMipmaps)); + cls->defineFunction("getMipmapsUuids", _SE(js_cc_Texture2D_getMipmapsUuids)); + cls->defineFunction("syncMipmapsForJS", _SE(js_cc_Texture2D_syncMipmapsForJS)); + cls->defineFunction("setMipmaps", _SE(js_cc_Texture2D_setMipmaps)); + cls->defineFunction("getImage", _SE(js_cc_Texture2D_getImage)); + cls->defineFunction("setImage", _SE(js_cc_Texture2D_setImage)); + cls->defineFunction("initialize", _SE(js_cc_Texture2D_initialize)); + cls->defineFunction("reset", _SE(js_cc_Texture2D_reset)); + cls->defineFunction("create", _SE(js_cc_Texture2D_create)); + cls->defineFunction("description", _SE(js_cc_Texture2D_description)); + cls->defineFunction("releaseTexture", _SE(js_cc_Texture2D_releaseTexture)); + cls->defineFunction("getGfxTextureCreateInfo", _SE(js_cc_Texture2D_getGfxTextureCreateInfo)); + cls->defineFunction("getGfxTextureViewCreateInfo", _SE(js_cc_Texture2D_getGfxTextureViewCreateInfo)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Texture2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Texture2D_proto = cls->getProto(); + __jsb_cc_Texture2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITextureCubeMipmap_class = nullptr; +se::Object* __jsb_cc_ITextureCubeMipmap_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITextureCubeMipmap) + +static bool js_cc_ITextureCubeMipmap_front_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->front, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_front_set) + +static bool js_cc_ITextureCubeMipmap_front_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->front, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->front, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_front_get) + +static bool js_cc_ITextureCubeMipmap_back_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->back, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_back_set) + +static bool js_cc_ITextureCubeMipmap_back_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->back, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->back, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_back_get) + +static bool js_cc_ITextureCubeMipmap_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_left_set) + +static bool js_cc_ITextureCubeMipmap_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->left, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_left_get) + +static bool js_cc_ITextureCubeMipmap_right_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->right, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_right_set) + +static bool js_cc_ITextureCubeMipmap_right_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->right, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->right, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_right_get) + +static bool js_cc_ITextureCubeMipmap_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_top_set) + +static bool js_cc_ITextureCubeMipmap_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->top, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_top_get) + +static bool js_cc_ITextureCubeMipmap_bottom_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bottom, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeMipmap_bottom_set) + +static bool js_cc_ITextureCubeMipmap_bottom_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeMipmap *arg1 = (cc::ITextureCubeMipmap *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bottom, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bottom, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeMipmap_bottom_get) + +static bool js_new_cc_ITextureCubeMipmap(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITextureCubeMipmap *result; + result = (cc::ITextureCubeMipmap *)new cc::ITextureCubeMipmap(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITextureCubeMipmap, __jsb_cc_ITextureCubeMipmap_class, js_delete_cc_ITextureCubeMipmap) + +static bool js_delete_cc_ITextureCubeMipmap(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITextureCubeMipmap) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeMipmap * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("front", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->front), ctx); + } + + + json->getProperty("back", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->back), ctx); + } + + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("right", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->right), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("bottom", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bottom), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITextureCubeMipmap(se::Object* obj) { + auto* cls = se::Class::create("ITextureCubeMipmap", obj, nullptr, _SE(js_new_cc_ITextureCubeMipmap)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("front", _SE(js_cc_ITextureCubeMipmap_front_get), _SE(js_cc_ITextureCubeMipmap_front_set)); + cls->defineProperty("back", _SE(js_cc_ITextureCubeMipmap_back_get), _SE(js_cc_ITextureCubeMipmap_back_set)); + cls->defineProperty("left", _SE(js_cc_ITextureCubeMipmap_left_get), _SE(js_cc_ITextureCubeMipmap_left_set)); + cls->defineProperty("right", _SE(js_cc_ITextureCubeMipmap_right_get), _SE(js_cc_ITextureCubeMipmap_right_set)); + cls->defineProperty("top", _SE(js_cc_ITextureCubeMipmap_top_get), _SE(js_cc_ITextureCubeMipmap_top_set)); + cls->defineProperty("bottom", _SE(js_cc_ITextureCubeMipmap_bottom_get), _SE(js_cc_ITextureCubeMipmap_bottom_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITextureCubeMipmap)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITextureCubeMipmap_proto = cls->getProto(); + __jsb_cc_ITextureCubeMipmap_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITextureCubeSerializeMipmapData_class = nullptr; +se::Object* __jsb_cc_ITextureCubeSerializeMipmapData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITextureCubeSerializeMipmapData) + +static bool js_cc_ITextureCubeSerializeMipmapData_front_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->front, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_front_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_front_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->front, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->front, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_front_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_back_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->back, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_back_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_back_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->back, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->back, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_back_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_left_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->left, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_left_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_right_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->right, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_right_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_right_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->right, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->right, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_right_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_top_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->top, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_top_get) + +static bool js_cc_ITextureCubeSerializeMipmapData_bottom_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bottom, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureCubeSerializeMipmapData_bottom_set) + +static bool js_cc_ITextureCubeSerializeMipmapData_bottom_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureCubeSerializeMipmapData *arg1 = (cc::ITextureCubeSerializeMipmapData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bottom, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bottom, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureCubeSerializeMipmapData_bottom_get) + +static bool js_new_cc_ITextureCubeSerializeMipmapData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITextureCubeSerializeMipmapData *result; + result = (cc::ITextureCubeSerializeMipmapData *)new cc::ITextureCubeSerializeMipmapData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITextureCubeSerializeMipmapData, __jsb_cc_ITextureCubeSerializeMipmapData_class, js_delete_cc_ITextureCubeSerializeMipmapData) + +static bool js_delete_cc_ITextureCubeSerializeMipmapData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITextureCubeSerializeMipmapData) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeSerializeMipmapData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("front", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->front), ctx); + } + + + json->getProperty("back", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->back), ctx); + } + + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("right", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->right), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("bottom", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bottom), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITextureCubeSerializeMipmapData(se::Object* obj) { + auto* cls = se::Class::create("ITextureCubeSerializeMipmapData", obj, nullptr, _SE(js_new_cc_ITextureCubeSerializeMipmapData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("front", _SE(js_cc_ITextureCubeSerializeMipmapData_front_get), _SE(js_cc_ITextureCubeSerializeMipmapData_front_set)); + cls->defineProperty("back", _SE(js_cc_ITextureCubeSerializeMipmapData_back_get), _SE(js_cc_ITextureCubeSerializeMipmapData_back_set)); + cls->defineProperty("left", _SE(js_cc_ITextureCubeSerializeMipmapData_left_get), _SE(js_cc_ITextureCubeSerializeMipmapData_left_set)); + cls->defineProperty("right", _SE(js_cc_ITextureCubeSerializeMipmapData_right_get), _SE(js_cc_ITextureCubeSerializeMipmapData_right_set)); + cls->defineProperty("top", _SE(js_cc_ITextureCubeSerializeMipmapData_top_get), _SE(js_cc_ITextureCubeSerializeMipmapData_top_set)); + cls->defineProperty("bottom", _SE(js_cc_ITextureCubeSerializeMipmapData_bottom_get), _SE(js_cc_ITextureCubeSerializeMipmapData_bottom_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITextureCubeSerializeMipmapData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITextureCubeSerializeMipmapData_proto = cls->getProto(); + __jsb_cc_ITextureCubeSerializeMipmapData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MipmapAtlasLayoutInfo_class = nullptr; +se::Object* __jsb_cc_MipmapAtlasLayoutInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MipmapAtlasLayoutInfo) + +static bool js_cc_MipmapAtlasLayoutInfo_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_left_set) + +static bool js_cc_MipmapAtlasLayoutInfo_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_left_get) + +static bool js_cc_MipmapAtlasLayoutInfo_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_top_set) + +static bool js_cc_MipmapAtlasLayoutInfo_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_top_get) + +static bool js_cc_MipmapAtlasLayoutInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_width_set) + +static bool js_cc_MipmapAtlasLayoutInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_width_get) + +static bool js_cc_MipmapAtlasLayoutInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_height_set) + +static bool js_cc_MipmapAtlasLayoutInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_height_get) + +static bool js_cc_MipmapAtlasLayoutInfo_level_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->level, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MipmapAtlasLayoutInfo_level_set) + +static bool js_cc_MipmapAtlasLayoutInfo_level_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MipmapAtlasLayoutInfo *arg1 = (cc::MipmapAtlasLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->level, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_MipmapAtlasLayoutInfo_level_get) + +static bool js_new_cc_MipmapAtlasLayoutInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MipmapAtlasLayoutInfo *result; + result = (cc::MipmapAtlasLayoutInfo *)new cc::MipmapAtlasLayoutInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MipmapAtlasLayoutInfo, __jsb_cc_MipmapAtlasLayoutInfo_class, js_delete_cc_MipmapAtlasLayoutInfo) + +static bool js_delete_cc_MipmapAtlasLayoutInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MipmapAtlasLayoutInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::MipmapAtlasLayoutInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("level", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->level), ctx); + } + + + return ok; +} + + +bool js_register_cc_MipmapAtlasLayoutInfo(se::Object* obj) { + auto* cls = se::Class::create("MipmapAtlasLayoutInfo", obj, nullptr, _SE(js_new_cc_MipmapAtlasLayoutInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("left", _SE(js_cc_MipmapAtlasLayoutInfo_left_get), _SE(js_cc_MipmapAtlasLayoutInfo_left_set)); + cls->defineProperty("top", _SE(js_cc_MipmapAtlasLayoutInfo_top_get), _SE(js_cc_MipmapAtlasLayoutInfo_top_set)); + cls->defineProperty("width", _SE(js_cc_MipmapAtlasLayoutInfo_width_get), _SE(js_cc_MipmapAtlasLayoutInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_MipmapAtlasLayoutInfo_height_get), _SE(js_cc_MipmapAtlasLayoutInfo_height_set)); + cls->defineProperty("level", _SE(js_cc_MipmapAtlasLayoutInfo_level_get), _SE(js_cc_MipmapAtlasLayoutInfo_level_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MipmapAtlasLayoutInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MipmapAtlasLayoutInfo_proto = cls->getProto(); + __jsb_cc_MipmapAtlasLayoutInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureCubeMipmapAtlasInfo_class = nullptr; +se::Object* __jsb_cc_TextureCubeMipmapAtlasInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureCubeMipmapAtlasInfo) + +static bool js_cc_TextureCubeMipmapAtlasInfo_atlas_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->atlas, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeMipmapAtlasInfo_atlas_set) + +static bool js_cc_TextureCubeMipmapAtlasInfo_atlas_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->atlas, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->atlas, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeMipmapAtlasInfo_atlas_get) + +static bool js_cc_TextureCubeMipmapAtlasInfo_layout_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layout, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeMipmapAtlasInfo_layout_set) + +static bool js_cc_TextureCubeMipmapAtlasInfo_layout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeMipmapAtlasInfo *arg1 = (cc::TextureCubeMipmapAtlasInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layout, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->layout, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeMipmapAtlasInfo_layout_get) + +static bool js_new_cc_TextureCubeMipmapAtlasInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureCubeMipmapAtlasInfo *result; + result = (cc::TextureCubeMipmapAtlasInfo *)new cc::TextureCubeMipmapAtlasInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureCubeMipmapAtlasInfo, __jsb_cc_TextureCubeMipmapAtlasInfo_class, js_delete_cc_TextureCubeMipmapAtlasInfo) + +static bool js_delete_cc_TextureCubeMipmapAtlasInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureCubeMipmapAtlasInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeMipmapAtlasInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("atlas", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->atlas), ctx); + } + + + json->getProperty("layout", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layout), ctx); + } + + + return ok; +} + + +bool js_register_cc_TextureCubeMipmapAtlasInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureCubeMipmapAtlasInfo", obj, nullptr, _SE(js_new_cc_TextureCubeMipmapAtlasInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("atlas", _SE(js_cc_TextureCubeMipmapAtlasInfo_atlas_get), _SE(js_cc_TextureCubeMipmapAtlasInfo_atlas_set)); + cls->defineProperty("layout", _SE(js_cc_TextureCubeMipmapAtlasInfo_layout_get), _SE(js_cc_TextureCubeMipmapAtlasInfo_layout_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureCubeMipmapAtlasInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureCubeMipmapAtlasInfo_proto = cls->getProto(); + __jsb_cc_TextureCubeMipmapAtlasInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureCubeSerializeData_class = nullptr; +se::Object* __jsb_cc_TextureCubeSerializeData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureCubeSerializeData) + +static bool js_cc_TextureCubeSerializeData_base_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->base, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_base_set) + +static bool js_cc_TextureCubeSerializeData_base_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->base, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->base, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_base_get) + +static bool js_cc_TextureCubeSerializeData_rgbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rgbe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_rgbe_set) + +static bool js_cc_TextureCubeSerializeData_rgbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rgbe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_rgbe_get) + +static bool js_cc_TextureCubeSerializeData_mipmapMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_mipmapMode_set) + +static bool js_cc_TextureCubeSerializeData_mipmapMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_mipmapMode_get) + +static bool js_cc_TextureCubeSerializeData_mipmaps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmaps, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_mipmaps_set) + +static bool js_cc_TextureCubeSerializeData_mipmaps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmaps, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmaps, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_mipmaps_get) + +static bool js_cc_TextureCubeSerializeData_mipmapAtlas_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapAtlas, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCubeSerializeData_mipmapAtlas_set) + +static bool js_cc_TextureCubeSerializeData_mipmapAtlas_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCubeSerializeData *arg1 = (cc::TextureCubeSerializeData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapAtlas, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapAtlas, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCubeSerializeData_mipmapAtlas_get) + +static bool js_new_cc_TextureCubeSerializeData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureCubeSerializeData *result; + result = (cc::TextureCubeSerializeData *)new cc::TextureCubeSerializeData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureCubeSerializeData, __jsb_cc_TextureCubeSerializeData_class, js_delete_cc_TextureCubeSerializeData) + +static bool js_delete_cc_TextureCubeSerializeData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureCubeSerializeData) + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeSerializeData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("base", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->base), ctx); + } + + + json->getProperty("rgbe", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rgbe), ctx); + } + + + json->getProperty("mipmapMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapMode), ctx); + } + + + json->getProperty("mipmaps", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmaps), ctx); + } + + + json->getProperty("mipmapAtlas", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapAtlas), ctx); + } + + + return ok; +} + + +bool js_register_cc_TextureCubeSerializeData(se::Object* obj) { + auto* cls = se::Class::create("TextureCubeSerializeData", obj, nullptr, _SE(js_new_cc_TextureCubeSerializeData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("base", _SE(js_cc_TextureCubeSerializeData_base_get), _SE(js_cc_TextureCubeSerializeData_base_set)); + cls->defineProperty("rgbe", _SE(js_cc_TextureCubeSerializeData_rgbe_get), _SE(js_cc_TextureCubeSerializeData_rgbe_set)); + cls->defineProperty("mipmapMode", _SE(js_cc_TextureCubeSerializeData_mipmapMode_get), _SE(js_cc_TextureCubeSerializeData_mipmapMode_set)); + cls->defineProperty("mipmaps", _SE(js_cc_TextureCubeSerializeData_mipmaps_get), _SE(js_cc_TextureCubeSerializeData_mipmaps_set)); + cls->defineProperty("mipmapAtlas", _SE(js_cc_TextureCubeSerializeData_mipmapAtlas_get), _SE(js_cc_TextureCubeSerializeData_mipmapAtlas_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureCubeSerializeData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureCubeSerializeData_proto = cls->getProto(); + __jsb_cc_TextureCubeSerializeData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextureCube_class = nullptr; +se::Object* __jsb_cc_TextureCube_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextureCube) + +static bool js_new_cc_TextureCube(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextureCube *result; + result = (cc::TextureCube *)new cc::TextureCube(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextureCube, __jsb_cc_TextureCube_class, js_delete_cc_TextureCube) + +static bool js_delete_cc_TextureCube(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextureCube) + +static bool js_cc_TextureCube_fromTexture2DArray_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< cc::Texture2D * > *arg1 = 0 ; + ccstd::vector< cc::Texture2D * > temp1 ; + cc::TextureCube *result = 0 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::TextureCube *)cc::TextureCube::fromTexture2DArray((ccstd::vector< cc::Texture2D * > const &)*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_FUNC(js_cc_TextureCube_fromTexture2DArray_static) + +static bool js_cc_TextureCube_getMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + ccstd::vector< cc::ITextureCubeMipmap > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::ITextureCubeMipmap > *) &((cc::TextureCube const *)arg1)->getMipmaps(); + + 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_TextureCube_getMipmaps) + +static bool js_cc_TextureCube_getMipmapAtlas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::TextureCubeMipmapAtlasInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::TextureCubeMipmapAtlasInfo *) &((cc::TextureCube const *)arg1)->getMipmapAtlas(); + + 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_TextureCube_getMipmapAtlas) + +static bool js_cc_TextureCube_setMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + ccstd::vector< cc::ITextureCubeMipmap > *arg2 = 0 ; + ccstd::vector< cc::ITextureCubeMipmap > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmaps((ccstd::vector< cc::ITextureCubeMipmap > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmaps) + +static bool js_cc_TextureCube_setMipmapsForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + ccstd::vector< cc::ITextureCubeMipmap > *arg2 = 0 ; + ccstd::vector< cc::ITextureCubeMipmap > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapsForJS((ccstd::vector< cc::ITextureCubeMipmap > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmapsForJS) + +static bool js_cc_TextureCube_setMipmapAtlasForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::TextureCubeMipmapAtlasInfo *arg2 = 0 ; + cc::TextureCubeMipmapAtlasInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapAtlasForJS((cc::TextureCubeMipmapAtlasInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmapAtlasForJS) + +static bool js_cc_TextureCube_setMipmapAtlas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::TextureCubeMipmapAtlasInfo *arg2 = 0 ; + cc::TextureCubeMipmapAtlasInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapAtlas((cc::TextureCubeMipmapAtlasInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setMipmapAtlas) + +static bool js_cc_TextureCube_getImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::ITextureCubeMipmap *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(s); + if (nullptr == arg1) return true; + result = (cc::ITextureCubeMipmap *)((cc::TextureCube const *)arg1)->getImage(); + + 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_TextureCube_getImage) + +static bool js_cc_TextureCube_setImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::ITextureCubeMipmap *arg2 = (cc::ITextureCubeMipmap *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setImage((cc::ITextureCubeMipmap const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_setImage) + +static bool js_cc_TextureCube_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::ITextureCubeCreateInfo *arg2 = 0 ; + cc::ITextureCubeCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::ITextureCubeCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_reset) + +static bool js_cc_TextureCube_releaseTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->releaseTexture(); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_releaseTexture) + +static bool js_cc_TextureCube_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_initialize) + +static bool js_cc_TextureCube_getGfxTextureCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::gfx::TextureUsageBit arg2 ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + cc::gfx::TextureFlagBit arg5 ; + cc::gfx::TextureInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_getGfxTextureCreateInfo) + +static bool js_cc_TextureCube_getGfxTextureViewCreateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::gfx::TextureViewInfo result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getGfxTextureViewCreateInfo(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_TextureCube_getGfxTextureViewCreateInfo) + +static bool js_cc_TextureCube__mipmapMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_mipmapMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCube__mipmapMode_set) + +static bool js_cc_TextureCube__mipmapMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_mipmapMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_mipmapMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCube__mipmapMode_get) + +static bool js_cc_TextureCube_isRGBE_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isRGBE); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextureCube_isRGBE_set) + +static bool js_cc_TextureCube_isRGBE_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextureCube *arg1 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isRGBE, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextureCube_isRGBE_get) + +bool js_register_cc_TextureCube(se::Object* obj) { + auto* cls = se::Class::create("TextureCube", obj, __jsb_cc_SimpleTexture_proto, _SE(js_new_cc_TextureCube)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_mipmapMode", _SE(js_cc_TextureCube__mipmapMode_get), _SE(js_cc_TextureCube__mipmapMode_set)); + cls->defineProperty("isRGBE", _SE(js_cc_TextureCube_isRGBE_get), _SE(js_cc_TextureCube_isRGBE_set)); + + cls->defineFunction("getMipmaps", _SE(js_cc_TextureCube_getMipmaps)); + cls->defineFunction("getMipmapAtlas", _SE(js_cc_TextureCube_getMipmapAtlas)); + cls->defineFunction("setMipmaps", _SE(js_cc_TextureCube_setMipmaps)); + cls->defineFunction("setMipmapsForJS", _SE(js_cc_TextureCube_setMipmapsForJS)); + cls->defineFunction("setMipmapAtlasForJS", _SE(js_cc_TextureCube_setMipmapAtlasForJS)); + cls->defineFunction("setMipmapAtlas", _SE(js_cc_TextureCube_setMipmapAtlas)); + cls->defineFunction("getImage", _SE(js_cc_TextureCube_getImage)); + cls->defineFunction("setImage", _SE(js_cc_TextureCube_setImage)); + cls->defineFunction("reset", _SE(js_cc_TextureCube_reset)); + cls->defineFunction("releaseTexture", _SE(js_cc_TextureCube_releaseTexture)); + cls->defineFunction("initialize", _SE(js_cc_TextureCube_initialize)); + cls->defineFunction("getGfxTextureCreateInfo", _SE(js_cc_TextureCube_getGfxTextureCreateInfo)); + cls->defineFunction("getGfxTextureViewCreateInfo", _SE(js_cc_TextureCube_getGfxTextureViewCreateInfo)); + + + cls->defineStaticFunction("fromTexture2DArray", _SE(js_cc_TextureCube_fromTexture2DArray_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextureCube)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextureCube_proto = cls->getProto(); + __jsb_cc_TextureCube_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IRenderTextureCreateInfo_class = nullptr; +se::Object* __jsb_cc_IRenderTextureCreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IRenderTextureCreateInfo) + +static bool js_cc_IRenderTextureCreateInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_name_set) + +static bool js_cc_IRenderTextureCreateInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_name_get) + +static bool js_cc_IRenderTextureCreateInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_width_set) + +static bool js_cc_IRenderTextureCreateInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_width_get) + +static bool js_cc_IRenderTextureCreateInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_height_set) + +static bool js_cc_IRenderTextureCreateInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_height_get) + +static bool js_cc_IRenderTextureCreateInfo_passInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_passInfo_set) + +static bool js_cc_IRenderTextureCreateInfo_passInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->passInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_passInfo_get) + +static bool js_cc_IRenderTextureCreateInfo_externalResLow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResLow, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_externalResLow_set) + +static bool js_cc_IRenderTextureCreateInfo_externalResLow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResLow, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResLow, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_externalResLow_get) + +static bool js_cc_IRenderTextureCreateInfo_externalResHigh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResHigh, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_externalResHigh_set) + +static bool js_cc_IRenderTextureCreateInfo_externalResHigh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResHigh, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResHigh, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_externalResHigh_get) + +static bool js_cc_IRenderTextureCreateInfo_externalFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalFlag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IRenderTextureCreateInfo_externalFlag_set) + +static bool js_cc_IRenderTextureCreateInfo_externalFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IRenderTextureCreateInfo *arg1 = (cc::IRenderTextureCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalFlag, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalFlag, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IRenderTextureCreateInfo_externalFlag_get) + +static bool js_new_cc_IRenderTextureCreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IRenderTextureCreateInfo *result; + result = (cc::IRenderTextureCreateInfo *)new cc::IRenderTextureCreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IRenderTextureCreateInfo, __jsb_cc_IRenderTextureCreateInfo_class, js_delete_cc_IRenderTextureCreateInfo) + +static bool js_delete_cc_IRenderTextureCreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IRenderTextureCreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IRenderTextureCreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("passInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passInfo), ctx); + } + + + json->getProperty("externalResLow", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResLow), ctx); + } + + + json->getProperty("externalResHigh", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResHigh), ctx); + } + + + json->getProperty("externalFlag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalFlag), ctx); + } + + + return ok; +} + + +bool js_register_cc_IRenderTextureCreateInfo(se::Object* obj) { + auto* cls = se::Class::create("IRenderTextureCreateInfo", obj, nullptr, _SE(js_new_cc_IRenderTextureCreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IRenderTextureCreateInfo_name_get), _SE(js_cc_IRenderTextureCreateInfo_name_set)); + cls->defineProperty("width", _SE(js_cc_IRenderTextureCreateInfo_width_get), _SE(js_cc_IRenderTextureCreateInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_IRenderTextureCreateInfo_height_get), _SE(js_cc_IRenderTextureCreateInfo_height_set)); + cls->defineProperty("passInfo", _SE(js_cc_IRenderTextureCreateInfo_passInfo_get), _SE(js_cc_IRenderTextureCreateInfo_passInfo_set)); + cls->defineProperty("externalResLow", _SE(js_cc_IRenderTextureCreateInfo_externalResLow_get), _SE(js_cc_IRenderTextureCreateInfo_externalResLow_set)); + cls->defineProperty("externalResHigh", _SE(js_cc_IRenderTextureCreateInfo_externalResHigh_get), _SE(js_cc_IRenderTextureCreateInfo_externalResHigh_set)); + cls->defineProperty("externalFlag", _SE(js_cc_IRenderTextureCreateInfo_externalFlag_get), _SE(js_cc_IRenderTextureCreateInfo_externalFlag_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IRenderTextureCreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IRenderTextureCreateInfo_proto = cls->getProto(); + __jsb_cc_IRenderTextureCreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderTexture_class = nullptr; +se::Object* __jsb_cc_RenderTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderTexture) + +static bool js_new_cc_RenderTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RenderTexture *result; + result = (cc::RenderTexture *)new cc::RenderTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RenderTexture, __jsb_cc_RenderTexture_class, js_delete_cc_RenderTexture) + +static bool js_delete_cc_RenderTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderTexture) + +static bool js_cc_RenderTexture_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::IRenderTextureCreateInfo *arg2 = 0 ; + cc::IRenderTextureCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::IRenderTextureCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_initialize) + +static bool js_cc_RenderTexture_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::IRenderTextureCreateInfo *arg2 = 0 ; + cc::IRenderTextureCreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::IRenderTextureCreateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_reset) + +static bool js_cc_RenderTexture_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_resize) + +static bool js_cc_RenderTexture_initWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initWindow(); + + + return true; +} + +static bool js_cc_RenderTexture_initWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::IRenderTextureCreateInfo *arg2 = 0 ; + cc::IRenderTextureCreateInfo temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initWindow((cc::IRenderTextureCreateInfo const &)*arg2); + + + return true; +} + +static bool js_cc_RenderTexture_initWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_RenderTexture_initWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_RenderTexture_initWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_RenderTexture_initWindow) + +static bool js_cc_RenderTexture_readPixels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::vector< uint8_t > result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::RenderTexture const *)arg1)->readPixels(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_RenderTexture_readPixels) + +static bool js_cc_RenderTexture_window_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderTexture *arg1 = (cc::RenderTexture *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_RenderTexture_window_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_RenderTexture_window_get) + +bool js_register_cc_RenderTexture(se::Object* obj) { + auto* cls = se::Class::create("RenderTexture", obj, __jsb_cc_TextureBase_proto, _SE(js_new_cc_RenderTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("window", _SE(js_cc_RenderTexture_window_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_RenderTexture_initialize)); + cls->defineFunction("reset", _SE(js_cc_RenderTexture_reset)); + cls->defineFunction("resize", _SE(js_cc_RenderTexture_resize)); + cls->defineFunction("initWindow", _SE(js_cc_RenderTexture_initWindow)); + cls->defineFunction("readPixels", _SE(js_cc_RenderTexture_readPixels)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderTexture_proto = cls->getProto(); + __jsb_cc_RenderTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BufferAsset_class = nullptr; +se::Object* __jsb_cc_BufferAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BufferAsset) + +static bool js_new_cc_BufferAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BufferAsset *result; + result = (cc::BufferAsset *)new cc::BufferAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BufferAsset, __jsb_cc_BufferAsset_class, js_delete_cc_BufferAsset) + +static bool js_delete_cc_BufferAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BufferAsset) + +static bool js_cc_BufferAsset_buffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BufferAsset *arg1 = (cc::BufferAsset *) NULL ; + cc::ArrayBuffer *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(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)((cc::BufferAsset const *)arg1)->getBuffer(); + + 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_BufferAsset_buffer) + +static bool js_cc_BufferAsset__nativeAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BufferAsset *arg1 = (cc::BufferAsset *) NULL ; + cc::ArrayBuffer *arg2 = (cc::ArrayBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_BufferAsset__nativeAsset_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_BufferAsset__nativeAsset_set) + +static bool js_cc_BufferAsset__nativeAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BufferAsset *arg1 = (cc::BufferAsset *) NULL ; + cc::ArrayBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)cc_BufferAsset__nativeAsset_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_BufferAsset__nativeAsset_get) + +bool js_register_cc_BufferAsset(se::Object* obj) { + auto* cls = se::Class::create("BufferAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_BufferAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_nativeAsset", _SE(js_cc_BufferAsset__nativeAsset_get), _SE(js_cc_BufferAsset__nativeAsset_set)); + + cls->defineFunction("buffer", _SE(js_cc_BufferAsset_buffer)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BufferAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BufferAsset_proto = cls->getProto(); + __jsb_cc_BufferAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IPropertyInfo_class = nullptr; +se::Object* __jsb_cc_IPropertyInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IPropertyInfo) + +static bool js_cc_IPropertyInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_type_set) + +static bool js_cc_IPropertyInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_type_get) + +static bool js_cc_IPropertyInfo_handleInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->handleInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_handleInfo_set) + +static bool js_cc_IPropertyInfo_handleInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->handleInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->handleInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_handleInfo_get) + +static bool js_cc_IPropertyInfo_samplerHash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerHash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_samplerHash_set) + +static bool js_cc_IPropertyInfo_samplerHash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerHash, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerHash, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_samplerHash_get) + +static bool js_cc_IPropertyInfo_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_value_set) + +static bool js_cc_IPropertyInfo_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->value, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_value_get) + +static bool js_cc_IPropertyInfo_linear_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linear, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_linear_set) + +static bool js_cc_IPropertyInfo_linear_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linear, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linear, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_linear_get) + +static bool js_cc_IPropertyInfo_editor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->editor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPropertyInfo_editor_set) + +static bool js_cc_IPropertyInfo_editor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPropertyInfo *arg1 = (cc::IPropertyInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->editor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->editor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPropertyInfo_editor_get) + +static bool js_new_cc_IPropertyInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IPropertyInfo *result; + result = (cc::IPropertyInfo *)new cc::IPropertyInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IPropertyInfo, __jsb_cc_IPropertyInfo_class, js_delete_cc_IPropertyInfo) + +static bool js_delete_cc_IPropertyInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IPropertyInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPropertyInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("handleInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->handleInfo), ctx); + } + + + json->getProperty("samplerHash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerHash), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + json->getProperty("linear", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linear), ctx); + } + + + json->getProperty("editor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->editor), ctx); + } + + + return ok; +} + + +bool js_register_cc_IPropertyInfo(se::Object* obj) { + auto* cls = se::Class::create("IPropertyInfo", obj, nullptr, _SE(js_new_cc_IPropertyInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_IPropertyInfo_type_get), _SE(js_cc_IPropertyInfo_type_set)); + cls->defineProperty("handleInfo", _SE(js_cc_IPropertyInfo_handleInfo_get), _SE(js_cc_IPropertyInfo_handleInfo_set)); + cls->defineProperty("samplerHash", _SE(js_cc_IPropertyInfo_samplerHash_get), _SE(js_cc_IPropertyInfo_samplerHash_set)); + cls->defineProperty("value", _SE(js_cc_IPropertyInfo_value_get), _SE(js_cc_IPropertyInfo_value_set)); + cls->defineProperty("linear", _SE(js_cc_IPropertyInfo_linear_get), _SE(js_cc_IPropertyInfo_linear_set)); + cls->defineProperty("editor", _SE(js_cc_IPropertyInfo_editor_get), _SE(js_cc_IPropertyInfo_editor_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IPropertyInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IPropertyInfo_proto = cls->getProto(); + __jsb_cc_IPropertyInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RasterizerStateInfo_class = nullptr; +se::Object* __jsb_cc_RasterizerStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RasterizerStateInfo) + +static bool js_cc_RasterizerStateInfo_isDiscard_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDiscard, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isDiscard_set) + +static bool js_cc_RasterizerStateInfo_isDiscard_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDiscard, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isDiscard, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isDiscard_get) + +static bool js_cc_RasterizerStateInfo_isFrontFaceCCW_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isFrontFaceCCW, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isFrontFaceCCW_set) + +static bool js_cc_RasterizerStateInfo_isFrontFaceCCW_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isFrontFaceCCW, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isFrontFaceCCW, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isFrontFaceCCW_get) + +static bool js_cc_RasterizerStateInfo_depthBiasEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasEnabled, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBiasEnabled_set) + +static bool js_cc_RasterizerStateInfo_depthBiasEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasEnabled, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBiasEnabled, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBiasEnabled_get) + +static bool js_cc_RasterizerStateInfo_isDepthClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDepthClip, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isDepthClip_set) + +static bool js_cc_RasterizerStateInfo_isDepthClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDepthClip, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isDepthClip, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isDepthClip_get) + +static bool js_cc_RasterizerStateInfo_isMultisample_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isMultisample, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_isMultisample_set) + +static bool js_cc_RasterizerStateInfo_isMultisample_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isMultisample, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isMultisample, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_isMultisample_get) + +static bool js_cc_RasterizerStateInfo_polygonMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->polygonMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_polygonMode_set) + +static bool js_cc_RasterizerStateInfo_polygonMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->polygonMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->polygonMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_polygonMode_get) + +static bool js_cc_RasterizerStateInfo_shadeModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadeModel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_shadeModel_set) + +static bool js_cc_RasterizerStateInfo_shadeModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadeModel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shadeModel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_shadeModel_get) + +static bool js_cc_RasterizerStateInfo_cullMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cullMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_cullMode_set) + +static bool js_cc_RasterizerStateInfo_cullMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cullMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cullMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_cullMode_get) + +static bool js_cc_RasterizerStateInfo_depthBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBias, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBias_set) + +static bool js_cc_RasterizerStateInfo_depthBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBias, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBias, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBias_get) + +static bool js_cc_RasterizerStateInfo_depthBiasClamp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasClamp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBiasClamp_set) + +static bool js_cc_RasterizerStateInfo_depthBiasClamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasClamp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBiasClamp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBiasClamp_get) + +static bool js_cc_RasterizerStateInfo_depthBiasSlop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasSlop, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_depthBiasSlop_set) + +static bool js_cc_RasterizerStateInfo_depthBiasSlop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasSlop, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthBiasSlop, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_depthBiasSlop_get) + +static bool js_cc_RasterizerStateInfo_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_RasterizerStateInfo_lineWidth_set) + +static bool js_cc_RasterizerStateInfo_lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lineWidth, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->lineWidth, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_RasterizerStateInfo_lineWidth_get) + +static bool js_cc_RasterizerStateInfo_fromGFXRasterizerState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + cc::gfx::RasterizerState *arg2 = 0 ; + cc::gfx::RasterizerState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXRasterizerState((cc::gfx::RasterizerState const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RasterizerStateInfo_fromGFXRasterizerState) + +static bool js_cc_RasterizerStateInfo_assignToGFXRasterizerState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RasterizerStateInfo *arg1 = (cc::RasterizerStateInfo *) NULL ; + cc::gfx::RasterizerState *arg2 = 0 ; + cc::gfx::RasterizerState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::RasterizerStateInfo const *)arg1)->assignToGFXRasterizerState(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RasterizerStateInfo_assignToGFXRasterizerState) + +static bool js_new_cc_RasterizerStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::RasterizerStateInfo *result; + result = (cc::RasterizerStateInfo *)new cc::RasterizerStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_RasterizerStateInfo, __jsb_cc_RasterizerStateInfo_class, js_delete_cc_RasterizerStateInfo) + +static bool js_delete_cc_RasterizerStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RasterizerStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::RasterizerStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isDiscard", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDiscard), ctx); + } + + + json->getProperty("isFrontFaceCCW", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isFrontFaceCCW), ctx); + } + + + json->getProperty("depthBiasEnabled", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasEnabled), ctx); + } + + + json->getProperty("isDepthClip", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDepthClip), ctx); + } + + + json->getProperty("isMultisample", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isMultisample), ctx); + } + + + json->getProperty("polygonMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->polygonMode), ctx); + } + + + json->getProperty("shadeModel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadeModel), ctx); + } + + + json->getProperty("cullMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cullMode), ctx); + } + + + json->getProperty("depthBias", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBias), ctx); + } + + + json->getProperty("depthBiasClamp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasClamp), ctx); + } + + + json->getProperty("depthBiasSlop", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasSlop), ctx); + } + + + json->getProperty("lineWidth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lineWidth), ctx); + } + + + return ok; +} + + +bool js_register_cc_RasterizerStateInfo(se::Object* obj) { + auto* cls = se::Class::create("RasterizerStateInfo", obj, nullptr, _SE(js_new_cc_RasterizerStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isDiscard", _SE(js_cc_RasterizerStateInfo_isDiscard_get), _SE(js_cc_RasterizerStateInfo_isDiscard_set)); + cls->defineProperty("isFrontFaceCCW", _SE(js_cc_RasterizerStateInfo_isFrontFaceCCW_get), _SE(js_cc_RasterizerStateInfo_isFrontFaceCCW_set)); + cls->defineProperty("depthBiasEnabled", _SE(js_cc_RasterizerStateInfo_depthBiasEnabled_get), _SE(js_cc_RasterizerStateInfo_depthBiasEnabled_set)); + cls->defineProperty("isDepthClip", _SE(js_cc_RasterizerStateInfo_isDepthClip_get), _SE(js_cc_RasterizerStateInfo_isDepthClip_set)); + cls->defineProperty("isMultisample", _SE(js_cc_RasterizerStateInfo_isMultisample_get), _SE(js_cc_RasterizerStateInfo_isMultisample_set)); + cls->defineProperty("polygonMode", _SE(js_cc_RasterizerStateInfo_polygonMode_get), _SE(js_cc_RasterizerStateInfo_polygonMode_set)); + cls->defineProperty("shadeModel", _SE(js_cc_RasterizerStateInfo_shadeModel_get), _SE(js_cc_RasterizerStateInfo_shadeModel_set)); + cls->defineProperty("cullMode", _SE(js_cc_RasterizerStateInfo_cullMode_get), _SE(js_cc_RasterizerStateInfo_cullMode_set)); + cls->defineProperty("depthBias", _SE(js_cc_RasterizerStateInfo_depthBias_get), _SE(js_cc_RasterizerStateInfo_depthBias_set)); + cls->defineProperty("depthBiasClamp", _SE(js_cc_RasterizerStateInfo_depthBiasClamp_get), _SE(js_cc_RasterizerStateInfo_depthBiasClamp_set)); + cls->defineProperty("depthBiasSlop", _SE(js_cc_RasterizerStateInfo_depthBiasSlop_get), _SE(js_cc_RasterizerStateInfo_depthBiasSlop_set)); + cls->defineProperty("lineWidth", _SE(js_cc_RasterizerStateInfo_lineWidth_get), _SE(js_cc_RasterizerStateInfo_lineWidth_set)); + + cls->defineFunction("fromGFXRasterizerState", _SE(js_cc_RasterizerStateInfo_fromGFXRasterizerState)); + cls->defineFunction("assignToGFXRasterizerState", _SE(js_cc_RasterizerStateInfo_assignToGFXRasterizerState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RasterizerStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RasterizerStateInfo_proto = cls->getProto(); + __jsb_cc_RasterizerStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_DepthStencilStateInfo_class = nullptr; +se::Object* __jsb_cc_DepthStencilStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DepthStencilStateInfo) + +static bool js_cc_DepthStencilStateInfo_depthTest_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthTest, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_depthTest_set) + +static bool js_cc_DepthStencilStateInfo_depthTest_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthTest, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthTest, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_depthTest_get) + +static bool js_cc_DepthStencilStateInfo_depthWrite_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthWrite, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_depthWrite_set) + +static bool js_cc_DepthStencilStateInfo_depthWrite_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthWrite, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthWrite, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_depthWrite_get) + +static bool js_cc_DepthStencilStateInfo_stencilTestFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilTestFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilTestFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilTestFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilTestFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilTestBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilTestBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilTestBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilTestBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilTestBack_get) + +static bool js_cc_DepthStencilStateInfo_depthFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_depthFunc_set) + +static bool js_cc_DepthStencilStateInfo_depthFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_depthFunc_get) + +static bool js_cc_DepthStencilStateInfo_stencilFuncFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFuncFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilFuncFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFuncFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilReadMaskFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilReadMaskFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilReadMaskFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilWriteMaskFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFailOpFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFailOpFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilZFailOpFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilZFailOpFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilPassOpFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilPassOpFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilRefFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilRefFront_set) + +static bool js_cc_DepthStencilStateInfo_stencilRefFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilRefFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilRefFront_get) + +static bool js_cc_DepthStencilStateInfo_stencilFuncBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFuncBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilFuncBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFuncBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilReadMaskBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilReadMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilReadMaskBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilReadMaskBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilWriteMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilWriteMaskBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilFailOpBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilFailOpBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilZFailOpBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilZFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilZFailOpBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilPassOpBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilPassOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilPassOpBack_get) + +static bool js_cc_DepthStencilStateInfo_stencilRefBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DepthStencilStateInfo_stencilRefBack_set) + +static bool js_cc_DepthStencilStateInfo_stencilRefBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilRefBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DepthStencilStateInfo_stencilRefBack_get) + +static bool js_cc_DepthStencilStateInfo_fromGFXDepthStencilState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + cc::gfx::DepthStencilState *arg2 = 0 ; + cc::gfx::DepthStencilState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXDepthStencilState((cc::gfx::DepthStencilState const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_DepthStencilStateInfo_fromGFXDepthStencilState) + +static bool js_cc_DepthStencilStateInfo_assignToGFXDepthStencilState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DepthStencilStateInfo *arg1 = (cc::DepthStencilStateInfo *) NULL ; + cc::gfx::DepthStencilState *arg2 = 0 ; + cc::gfx::DepthStencilState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::DepthStencilStateInfo const *)arg1)->assignToGFXDepthStencilState(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_DepthStencilStateInfo_assignToGFXDepthStencilState) + +static bool js_new_cc_DepthStencilStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DepthStencilStateInfo *result; + result = (cc::DepthStencilStateInfo *)new cc::DepthStencilStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DepthStencilStateInfo, __jsb_cc_DepthStencilStateInfo_class, js_delete_cc_DepthStencilStateInfo) + +static bool js_delete_cc_DepthStencilStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DepthStencilStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::DepthStencilStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("depthTest", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthTest), ctx); + } + + + json->getProperty("depthWrite", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthWrite), ctx); + } + + + json->getProperty("stencilTestFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestFront), ctx); + } + + + json->getProperty("stencilTestBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestBack), ctx); + } + + + json->getProperty("depthFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthFunc), ctx); + } + + + json->getProperty("stencilFuncFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncFront), ctx); + } + + + json->getProperty("stencilReadMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskFront), ctx); + } + + + json->getProperty("stencilWriteMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskFront), ctx); + } + + + json->getProperty("stencilFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpFront), ctx); + } + + + json->getProperty("stencilZFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpFront), ctx); + } + + + json->getProperty("stencilPassOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpFront), ctx); + } + + + json->getProperty("stencilRefFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefFront), ctx); + } + + + json->getProperty("stencilFuncBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncBack), ctx); + } + + + json->getProperty("stencilReadMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskBack), ctx); + } + + + json->getProperty("stencilWriteMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskBack), ctx); + } + + + json->getProperty("stencilFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpBack), ctx); + } + + + json->getProperty("stencilZFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpBack), ctx); + } + + + json->getProperty("stencilPassOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpBack), ctx); + } + + + json->getProperty("stencilRefBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefBack), ctx); + } + + + return ok; +} + + +bool js_register_cc_DepthStencilStateInfo(se::Object* obj) { + auto* cls = se::Class::create("DepthStencilStateInfo", obj, nullptr, _SE(js_new_cc_DepthStencilStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("depthTest", _SE(js_cc_DepthStencilStateInfo_depthTest_get), _SE(js_cc_DepthStencilStateInfo_depthTest_set)); + cls->defineProperty("depthWrite", _SE(js_cc_DepthStencilStateInfo_depthWrite_get), _SE(js_cc_DepthStencilStateInfo_depthWrite_set)); + cls->defineProperty("stencilTestFront", _SE(js_cc_DepthStencilStateInfo_stencilTestFront_get), _SE(js_cc_DepthStencilStateInfo_stencilTestFront_set)); + cls->defineProperty("stencilTestBack", _SE(js_cc_DepthStencilStateInfo_stencilTestBack_get), _SE(js_cc_DepthStencilStateInfo_stencilTestBack_set)); + cls->defineProperty("depthFunc", _SE(js_cc_DepthStencilStateInfo_depthFunc_get), _SE(js_cc_DepthStencilStateInfo_depthFunc_set)); + cls->defineProperty("stencilFuncFront", _SE(js_cc_DepthStencilStateInfo_stencilFuncFront_get), _SE(js_cc_DepthStencilStateInfo_stencilFuncFront_set)); + cls->defineProperty("stencilReadMaskFront", _SE(js_cc_DepthStencilStateInfo_stencilReadMaskFront_get), _SE(js_cc_DepthStencilStateInfo_stencilReadMaskFront_set)); + cls->defineProperty("stencilWriteMaskFront", _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_get), _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskFront_set)); + cls->defineProperty("stencilFailOpFront", _SE(js_cc_DepthStencilStateInfo_stencilFailOpFront_get), _SE(js_cc_DepthStencilStateInfo_stencilFailOpFront_set)); + cls->defineProperty("stencilZFailOpFront", _SE(js_cc_DepthStencilStateInfo_stencilZFailOpFront_get), _SE(js_cc_DepthStencilStateInfo_stencilZFailOpFront_set)); + cls->defineProperty("stencilPassOpFront", _SE(js_cc_DepthStencilStateInfo_stencilPassOpFront_get), _SE(js_cc_DepthStencilStateInfo_stencilPassOpFront_set)); + cls->defineProperty("stencilRefFront", _SE(js_cc_DepthStencilStateInfo_stencilRefFront_get), _SE(js_cc_DepthStencilStateInfo_stencilRefFront_set)); + cls->defineProperty("stencilFuncBack", _SE(js_cc_DepthStencilStateInfo_stencilFuncBack_get), _SE(js_cc_DepthStencilStateInfo_stencilFuncBack_set)); + cls->defineProperty("stencilReadMaskBack", _SE(js_cc_DepthStencilStateInfo_stencilReadMaskBack_get), _SE(js_cc_DepthStencilStateInfo_stencilReadMaskBack_set)); + cls->defineProperty("stencilWriteMaskBack", _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_get), _SE(js_cc_DepthStencilStateInfo_stencilWriteMaskBack_set)); + cls->defineProperty("stencilFailOpBack", _SE(js_cc_DepthStencilStateInfo_stencilFailOpBack_get), _SE(js_cc_DepthStencilStateInfo_stencilFailOpBack_set)); + cls->defineProperty("stencilZFailOpBack", _SE(js_cc_DepthStencilStateInfo_stencilZFailOpBack_get), _SE(js_cc_DepthStencilStateInfo_stencilZFailOpBack_set)); + cls->defineProperty("stencilPassOpBack", _SE(js_cc_DepthStencilStateInfo_stencilPassOpBack_get), _SE(js_cc_DepthStencilStateInfo_stencilPassOpBack_set)); + cls->defineProperty("stencilRefBack", _SE(js_cc_DepthStencilStateInfo_stencilRefBack_get), _SE(js_cc_DepthStencilStateInfo_stencilRefBack_set)); + + cls->defineFunction("fromGFXDepthStencilState", _SE(js_cc_DepthStencilStateInfo_fromGFXDepthStencilState)); + cls->defineFunction("assignToGFXDepthStencilState", _SE(js_cc_DepthStencilStateInfo_assignToGFXDepthStencilState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DepthStencilStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DepthStencilStateInfo_proto = cls->getProto(); + __jsb_cc_DepthStencilStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BlendTargetInfo_class = nullptr; +se::Object* __jsb_cc_BlendTargetInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BlendTargetInfo) + +static bool js_cc_BlendTargetInfo_blend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blend_set) + +static bool js_cc_BlendTargetInfo_blend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blend, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blend, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blend_get) + +static bool js_cc_BlendTargetInfo_blendSrc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendSrc_set) + +static bool js_cc_BlendTargetInfo_blendSrc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendSrc_get) + +static bool js_cc_BlendTargetInfo_blendDst_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDst, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendDst_set) + +static bool js_cc_BlendTargetInfo_blendDst_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDst, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDst, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendDst_get) + +static bool js_cc_BlendTargetInfo_blendEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendEq_set) + +static bool js_cc_BlendTargetInfo_blendEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendEq_get) + +static bool js_cc_BlendTargetInfo_blendSrcAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrcAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendSrcAlpha_set) + +static bool js_cc_BlendTargetInfo_blendSrcAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrcAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrcAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendSrcAlpha_get) + +static bool js_cc_BlendTargetInfo_blendDstAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDstAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendDstAlpha_set) + +static bool js_cc_BlendTargetInfo_blendDstAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDstAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDstAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendDstAlpha_get) + +static bool js_cc_BlendTargetInfo_blendAlphaEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendAlphaEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendAlphaEq_set) + +static bool js_cc_BlendTargetInfo_blendAlphaEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendAlphaEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendAlphaEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendAlphaEq_get) + +static bool js_cc_BlendTargetInfo_blendColorMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColorMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendTargetInfo_blendColorMask_set) + +static bool js_cc_BlendTargetInfo_blendColorMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColorMask, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColorMask, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendTargetInfo_blendColorMask_get) + +static bool js_cc_BlendTargetInfo_fromGFXBlendTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + cc::gfx::BlendTarget *arg2 = 0 ; + cc::gfx::BlendTarget temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXBlendTarget((cc::gfx::BlendTarget const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendTargetInfo_fromGFXBlendTarget) + +static bool js_cc_BlendTargetInfo_assignToGFXBlendTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendTargetInfo *arg1 = (cc::BlendTargetInfo *) NULL ; + cc::gfx::BlendTarget *arg2 = 0 ; + cc::gfx::BlendTarget temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::BlendTargetInfo const *)arg1)->assignToGFXBlendTarget(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendTargetInfo_assignToGFXBlendTarget) + +static bool js_new_cc_BlendTargetInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BlendTargetInfo *result; + result = (cc::BlendTargetInfo *)new cc::BlendTargetInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BlendTargetInfo, __jsb_cc_BlendTargetInfo_class, js_delete_cc_BlendTargetInfo) + +static bool js_delete_cc_BlendTargetInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BlendTargetInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendTargetInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("blend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blend), ctx); + } + + + json->getProperty("blendSrc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrc), ctx); + } + + + json->getProperty("blendDst", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDst), ctx); + } + + + json->getProperty("blendEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendEq), ctx); + } + + + json->getProperty("blendSrcAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrcAlpha), ctx); + } + + + json->getProperty("blendDstAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDstAlpha), ctx); + } + + + json->getProperty("blendAlphaEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendAlphaEq), ctx); + } + + + json->getProperty("blendColorMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColorMask), ctx); + } + + + return ok; +} + + +bool js_register_cc_BlendTargetInfo(se::Object* obj) { + auto* cls = se::Class::create("BlendTargetInfo", obj, nullptr, _SE(js_new_cc_BlendTargetInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("blend", _SE(js_cc_BlendTargetInfo_blend_get), _SE(js_cc_BlendTargetInfo_blend_set)); + cls->defineProperty("blendSrc", _SE(js_cc_BlendTargetInfo_blendSrc_get), _SE(js_cc_BlendTargetInfo_blendSrc_set)); + cls->defineProperty("blendDst", _SE(js_cc_BlendTargetInfo_blendDst_get), _SE(js_cc_BlendTargetInfo_blendDst_set)); + cls->defineProperty("blendEq", _SE(js_cc_BlendTargetInfo_blendEq_get), _SE(js_cc_BlendTargetInfo_blendEq_set)); + cls->defineProperty("blendSrcAlpha", _SE(js_cc_BlendTargetInfo_blendSrcAlpha_get), _SE(js_cc_BlendTargetInfo_blendSrcAlpha_set)); + cls->defineProperty("blendDstAlpha", _SE(js_cc_BlendTargetInfo_blendDstAlpha_get), _SE(js_cc_BlendTargetInfo_blendDstAlpha_set)); + cls->defineProperty("blendAlphaEq", _SE(js_cc_BlendTargetInfo_blendAlphaEq_get), _SE(js_cc_BlendTargetInfo_blendAlphaEq_set)); + cls->defineProperty("blendColorMask", _SE(js_cc_BlendTargetInfo_blendColorMask_get), _SE(js_cc_BlendTargetInfo_blendColorMask_set)); + + cls->defineFunction("fromGFXBlendTarget", _SE(js_cc_BlendTargetInfo_fromGFXBlendTarget)); + cls->defineFunction("assignToGFXBlendTarget", _SE(js_cc_BlendTargetInfo_assignToGFXBlendTarget)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BlendTargetInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BlendTargetInfo_proto = cls->getProto(); + __jsb_cc_BlendTargetInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BlendStateInfo_class = nullptr; +se::Object* __jsb_cc_BlendStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BlendStateInfo) + +static bool js_cc_BlendStateInfo_isA2C_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isA2C, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_isA2C_set) + +static bool js_cc_BlendStateInfo_isA2C_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isA2C, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isA2C, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_isA2C_get) + +static bool js_cc_BlendStateInfo_isIndepend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isIndepend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_isIndepend_set) + +static bool js_cc_BlendStateInfo_isIndepend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isIndepend, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->isIndepend, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_isIndepend_get) + +static bool js_cc_BlendStateInfo_blendColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_blendColor_set) + +static bool js_cc_BlendStateInfo_blendColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_blendColor_get) + +static bool js_cc_BlendStateInfo_targets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_BlendStateInfo_targets_set) + +static bool js_cc_BlendStateInfo_targets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targets, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targets, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_BlendStateInfo_targets_get) + +static bool js_cc_BlendStateInfo_fromGFXBlendState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + cc::gfx::BlendState *arg2 = 0 ; + cc::gfx::BlendState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fromGFXBlendState((cc::gfx::BlendState const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendStateInfo_fromGFXBlendState) + +static bool js_cc_BlendStateInfo_assignToGFXBlendState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BlendStateInfo *arg1 = (cc::BlendStateInfo *) NULL ; + cc::gfx::BlendState *arg2 = 0 ; + cc::gfx::BlendState temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + ((cc::BlendStateInfo const *)arg1)->assignToGFXBlendState(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BlendStateInfo_assignToGFXBlendState) + +static bool js_new_cc_BlendStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BlendStateInfo *result; + result = (cc::BlendStateInfo *)new cc::BlendStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BlendStateInfo, __jsb_cc_BlendStateInfo_class, js_delete_cc_BlendStateInfo) + +static bool js_delete_cc_BlendStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BlendStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isA2C", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isA2C), ctx); + } + + + json->getProperty("isIndepend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isIndepend), ctx); + } + + + json->getProperty("blendColor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColor), ctx); + } + + + json->getProperty("targets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targets), ctx); + } + + + return ok; +} + + +bool js_register_cc_BlendStateInfo(se::Object* obj) { + auto* cls = se::Class::create("BlendStateInfo", obj, nullptr, _SE(js_new_cc_BlendStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isA2C", _SE(js_cc_BlendStateInfo_isA2C_get), _SE(js_cc_BlendStateInfo_isA2C_set)); + cls->defineProperty("isIndepend", _SE(js_cc_BlendStateInfo_isIndepend_get), _SE(js_cc_BlendStateInfo_isIndepend_set)); + cls->defineProperty("blendColor", _SE(js_cc_BlendStateInfo_blendColor_get), _SE(js_cc_BlendStateInfo_blendColor_set)); + cls->defineProperty("targets", _SE(js_cc_BlendStateInfo_targets_get), _SE(js_cc_BlendStateInfo_targets_set)); + + cls->defineFunction("fromGFXBlendState", _SE(js_cc_BlendStateInfo_fromGFXBlendState)); + cls->defineFunction("assignToGFXBlendState", _SE(js_cc_BlendStateInfo_assignToGFXBlendState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BlendStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BlendStateInfo_proto = cls->getProto(); + __jsb_cc_BlendStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IPassStates_class = nullptr; +se::Object* __jsb_cc_IPassStates_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IPassStates) + +static bool js_cc_IPassStates_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_priority_set) + +static bool js_cc_IPassStates_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->priority, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_priority_get) + +static bool js_cc_IPassStates_primitive_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitive, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_primitive_set) + +static bool js_cc_IPassStates_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitive, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitive, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_primitive_get) + +static bool js_cc_IPassStates_stage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_stage_set) + +static bool js_cc_IPassStates_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_stage_get) + +static bool js_cc_IPassStates_rasterizerState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rasterizerState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_rasterizerState_set) + +static bool js_cc_IPassStates_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rasterizerState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rasterizerState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_rasterizerState_get) + +static bool js_cc_IPassStates_depthStencilState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_depthStencilState_set) + +static bool js_cc_IPassStates_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_depthStencilState_get) + +static bool js_cc_IPassStates_blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_blendState_set) + +static bool js_cc_IPassStates_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_blendState_get) + +static bool js_cc_IPassStates_dynamicStates_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamicStates, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_dynamicStates_set) + +static bool js_cc_IPassStates_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamicStates, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamicStates, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_dynamicStates_get) + +static bool js_cc_IPassStates_phase_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->phase, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_phase_set) + +static bool js_cc_IPassStates_phase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->phase, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->phase, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_phase_get) + +static bool js_cc_IPassStates_pass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_pass_set) + +static bool js_cc_IPassStates_pass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_pass_get) + +static bool js_cc_IPassStates_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassStates_subpass_set) + +static bool js_cc_IPassStates_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassStates_subpass_get) + +static bool js_new_cc_IPassStates__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassStates *result; + result = (cc::IPassStates *)new cc::IPassStates(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassStates__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = 0 ; + cc::IPassInfoFull temp1 ; + cc::IPassStates *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::IPassStates *)new cc::IPassStates((cc::IPassInfoFull const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassStates(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_IPassStates__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_IPassStates__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of IPassStates"); + return false; +} +SE_BIND_CTOR(js_new_cc_IPassStates, __jsb_cc_IPassStates_class, js_delete_cc_IPassStates) + +static bool js_cc_IPassStates_overrides(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassStates *arg1 = (cc::IPassStates *) NULL ; + cc::IPassInfoFull *arg2 = 0 ; + cc::IPassInfoFull temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->overrides((cc::IPassInfoFull const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_IPassStates_overrides) + +static bool js_delete_cc_IPassStates(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IPassStates) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassStates * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("primitive", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitive), ctx); + } + + + json->getProperty("stage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stage), ctx); + } + + + json->getProperty("rasterizerState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rasterizerState), ctx); + } + + + json->getProperty("depthStencilState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilState), ctx); + } + + + json->getProperty("blendState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendState), ctx); + } + + + json->getProperty("dynamicStates", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamicStates), ctx); + } + + + json->getProperty("phase", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->phase), ctx); + } + + + json->getProperty("pass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pass), ctx); + } + + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + return ok; +} + + +bool js_register_cc_IPassStates(se::Object* obj) { + auto* cls = se::Class::create("IPassStates", obj, nullptr, _SE(js_new_cc_IPassStates)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("priority", _SE(js_cc_IPassStates_priority_get), _SE(js_cc_IPassStates_priority_set)); + cls->defineProperty("primitive", _SE(js_cc_IPassStates_primitive_get), _SE(js_cc_IPassStates_primitive_set)); + cls->defineProperty("stage", _SE(js_cc_IPassStates_stage_get), _SE(js_cc_IPassStates_stage_set)); + cls->defineProperty("rasterizerState", _SE(js_cc_IPassStates_rasterizerState_get), _SE(js_cc_IPassStates_rasterizerState_set)); + cls->defineProperty("depthStencilState", _SE(js_cc_IPassStates_depthStencilState_get), _SE(js_cc_IPassStates_depthStencilState_set)); + cls->defineProperty("blendState", _SE(js_cc_IPassStates_blendState_get), _SE(js_cc_IPassStates_blendState_set)); + cls->defineProperty("dynamicStates", _SE(js_cc_IPassStates_dynamicStates_get), _SE(js_cc_IPassStates_dynamicStates_set)); + cls->defineProperty("phase", _SE(js_cc_IPassStates_phase_get), _SE(js_cc_IPassStates_phase_set)); + cls->defineProperty("pass", _SE(js_cc_IPassStates_pass_get), _SE(js_cc_IPassStates_pass_set)); + cls->defineProperty("subpass", _SE(js_cc_IPassStates_subpass_get), _SE(js_cc_IPassStates_subpass_set)); + + cls->defineFunction("overrides", _SE(js_cc_IPassStates_overrides)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IPassStates)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IPassStates_proto = cls->getProto(); + __jsb_cc_IPassStates_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IPassInfoFull_class = nullptr; +se::Object* __jsb_cc_IPassInfoFull_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IPassInfoFull) + +static bool js_cc_IPassInfoFull_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_priority_set) + +static bool js_cc_IPassInfoFull_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->priority, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_priority_get) + +static bool js_cc_IPassInfoFull_primitive_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitive, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_primitive_set) + +static bool js_cc_IPassInfoFull_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitive, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitive, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_primitive_get) + +static bool js_cc_IPassInfoFull_stage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_stage_set) + +static bool js_cc_IPassInfoFull_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_stage_get) + +static bool js_cc_IPassInfoFull_rasterizerState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rasterizerState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_rasterizerState_set) + +static bool js_cc_IPassInfoFull_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rasterizerState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rasterizerState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_rasterizerState_get) + +static bool js_cc_IPassInfoFull_depthStencilState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_depthStencilState_set) + +static bool js_cc_IPassInfoFull_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_depthStencilState_get) + +static bool js_cc_IPassInfoFull_blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_blendState_set) + +static bool js_cc_IPassInfoFull_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_blendState_get) + +static bool js_cc_IPassInfoFull_dynamicStates_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamicStates, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_dynamicStates_set) + +static bool js_cc_IPassInfoFull_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamicStates, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamicStates, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_dynamicStates_get) + +static bool js_cc_IPassInfoFull_phase_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->phase, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_phase_set) + +static bool js_cc_IPassInfoFull_phase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->phase, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->phase, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_phase_get) + +static bool js_cc_IPassInfoFull_pass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_pass_set) + +static bool js_cc_IPassInfoFull_pass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_pass_get) + +static bool js_cc_IPassInfoFull_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_subpass_set) + +static bool js_cc_IPassInfoFull_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_subpass_get) + +static bool js_cc_IPassInfoFull_program_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->program, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_program_set) + +static bool js_cc_IPassInfoFull_program_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->program, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->program, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_program_get) + +static bool js_cc_IPassInfoFull_embeddedMacros_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->embeddedMacros, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_embeddedMacros_set) + +static bool js_cc_IPassInfoFull_embeddedMacros_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->embeddedMacros, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->embeddedMacros, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_embeddedMacros_get) + +static bool js_cc_IPassInfoFull_propertyIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->propertyIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_propertyIndex_set) + +static bool js_cc_IPassInfoFull_propertyIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->propertyIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->propertyIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_propertyIndex_get) + +static bool js_cc_IPassInfoFull_cpp_keyword_switch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->switch_, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_cpp_keyword_switch_set) + +static bool js_cc_IPassInfoFull_cpp_keyword_switch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->switch_, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->switch_, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_cpp_keyword_switch_get) + +static bool js_cc_IPassInfoFull_properties_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->properties, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_properties_set) + +static bool js_cc_IPassInfoFull_properties_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->properties, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->properties, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_properties_get) + +static bool js_cc_IPassInfoFull_passIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_passIndex_set) + +static bool js_cc_IPassInfoFull_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_passIndex_get) + +static bool js_cc_IPassInfoFull_subpassID_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassID, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_subpassID_set) + +static bool js_cc_IPassInfoFull_subpassID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassID, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_subpassID_get) + +static bool js_cc_IPassInfoFull_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_defines_set) + +static bool js_cc_IPassInfoFull_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_defines_get) + +static bool js_cc_IPassInfoFull_stateOverrides_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stateOverrides, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IPassInfoFull_stateOverrides_set) + +static bool js_cc_IPassInfoFull_stateOverrides_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IPassInfoFull *arg1 = (cc::IPassInfoFull *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stateOverrides, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stateOverrides, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IPassInfoFull_stateOverrides_get) + +static bool js_new_cc_IPassInfoFull__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassInfoFull *result; + result = (cc::IPassInfoFull *)new cc::IPassInfoFull(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassInfoFull__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::IPassStates *arg1 = 0 ; + cc::IPassStates temp1 ; + cc::IPassInfoFull *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::IPassInfoFull *)new cc::IPassInfoFull((cc::IPassStates const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_IPassInfoFull(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_IPassInfoFull__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_IPassInfoFull__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of IPassInfoFull"); + return false; +} +SE_BIND_CTOR(js_new_cc_IPassInfoFull, __jsb_cc_IPassInfoFull_class, js_delete_cc_IPassInfoFull) + +static bool js_delete_cc_IPassInfoFull(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IPassInfoFull) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassInfoFull * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("primitive", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitive), ctx); + } + + + json->getProperty("stage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stage), ctx); + } + + + json->getProperty("rasterizerState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rasterizerState), ctx); + } + + + json->getProperty("depthStencilState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilState), ctx); + } + + + json->getProperty("blendState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendState), ctx); + } + + + json->getProperty("dynamicStates", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamicStates), ctx); + } + + + json->getProperty("phase", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->phase), ctx); + } + + + json->getProperty("pass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pass), ctx); + } + + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + json->getProperty("program", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->program), ctx); + } + + + json->getProperty("embeddedMacros", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->embeddedMacros), ctx); + } + + + json->getProperty("propertyIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->propertyIndex), ctx); + } + + + json->getProperty("switch", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->switch_), ctx); + } + + + json->getProperty("properties", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->properties), ctx); + } + + + json->getProperty("passIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passIndex), ctx); + } + + + json->getProperty("subpassID", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassID), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("stateOverrides", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stateOverrides), ctx); + } + + + return ok; +} + + +bool js_register_cc_IPassInfoFull(se::Object* obj) { + auto* cls = se::Class::create("IPassInfoFull", obj, nullptr, _SE(js_new_cc_IPassInfoFull)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("priority", _SE(js_cc_IPassInfoFull_priority_get), _SE(js_cc_IPassInfoFull_priority_set)); + cls->defineProperty("primitive", _SE(js_cc_IPassInfoFull_primitive_get), _SE(js_cc_IPassInfoFull_primitive_set)); + cls->defineProperty("stage", _SE(js_cc_IPassInfoFull_stage_get), _SE(js_cc_IPassInfoFull_stage_set)); + cls->defineProperty("rasterizerState", _SE(js_cc_IPassInfoFull_rasterizerState_get), _SE(js_cc_IPassInfoFull_rasterizerState_set)); + cls->defineProperty("depthStencilState", _SE(js_cc_IPassInfoFull_depthStencilState_get), _SE(js_cc_IPassInfoFull_depthStencilState_set)); + cls->defineProperty("blendState", _SE(js_cc_IPassInfoFull_blendState_get), _SE(js_cc_IPassInfoFull_blendState_set)); + cls->defineProperty("dynamicStates", _SE(js_cc_IPassInfoFull_dynamicStates_get), _SE(js_cc_IPassInfoFull_dynamicStates_set)); + cls->defineProperty("phase", _SE(js_cc_IPassInfoFull_phase_get), _SE(js_cc_IPassInfoFull_phase_set)); + cls->defineProperty("pass", _SE(js_cc_IPassInfoFull_pass_get), _SE(js_cc_IPassInfoFull_pass_set)); + cls->defineProperty("subpass", _SE(js_cc_IPassInfoFull_subpass_get), _SE(js_cc_IPassInfoFull_subpass_set)); + cls->defineProperty("program", _SE(js_cc_IPassInfoFull_program_get), _SE(js_cc_IPassInfoFull_program_set)); + cls->defineProperty("embeddedMacros", _SE(js_cc_IPassInfoFull_embeddedMacros_get), _SE(js_cc_IPassInfoFull_embeddedMacros_set)); + cls->defineProperty("propertyIndex", _SE(js_cc_IPassInfoFull_propertyIndex_get), _SE(js_cc_IPassInfoFull_propertyIndex_set)); + cls->defineProperty("switch", _SE(js_cc_IPassInfoFull_cpp_keyword_switch_get), _SE(js_cc_IPassInfoFull_cpp_keyword_switch_set)); + cls->defineProperty("properties", _SE(js_cc_IPassInfoFull_properties_get), _SE(js_cc_IPassInfoFull_properties_set)); + cls->defineProperty("passIndex", _SE(js_cc_IPassInfoFull_passIndex_get), _SE(js_cc_IPassInfoFull_passIndex_set)); + cls->defineProperty("subpassID", _SE(js_cc_IPassInfoFull_subpassID_get), _SE(js_cc_IPassInfoFull_subpassID_set)); + cls->defineProperty("defines", _SE(js_cc_IPassInfoFull_defines_get), _SE(js_cc_IPassInfoFull_defines_set)); + cls->defineProperty("stateOverrides", _SE(js_cc_IPassInfoFull_stateOverrides_get), _SE(js_cc_IPassInfoFull_stateOverrides_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IPassInfoFull)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IPassInfoFull_proto = cls->getProto(); + __jsb_cc_IPassInfoFull_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITechniqueInfo_class = nullptr; +se::Object* __jsb_cc_ITechniqueInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITechniqueInfo) + +static bool js_cc_ITechniqueInfo_passes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITechniqueInfo_passes_set) + +static bool js_cc_ITechniqueInfo_passes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->passes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITechniqueInfo_passes_get) + +static bool js_cc_ITechniqueInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITechniqueInfo_name_set) + +static bool js_cc_ITechniqueInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITechniqueInfo *arg1 = (cc::ITechniqueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITechniqueInfo_name_get) + +static bool js_new_cc_ITechniqueInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITechniqueInfo *result; + result = (cc::ITechniqueInfo *)new cc::ITechniqueInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITechniqueInfo, __jsb_cc_ITechniqueInfo_class, js_delete_cc_ITechniqueInfo) + +static bool js_delete_cc_ITechniqueInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITechniqueInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITechniqueInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("passes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passes), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITechniqueInfo(se::Object* obj) { + auto* cls = se::Class::create("ITechniqueInfo", obj, nullptr, _SE(js_new_cc_ITechniqueInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("passes", _SE(js_cc_ITechniqueInfo_passes_get), _SE(js_cc_ITechniqueInfo_passes_set)); + cls->defineProperty("name", _SE(js_cc_ITechniqueInfo_name_get), _SE(js_cc_ITechniqueInfo_name_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITechniqueInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITechniqueInfo_proto = cls->getProto(); + __jsb_cc_ITechniqueInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBlockInfo_class = nullptr; +se::Object* __jsb_cc_IBlockInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBlockInfo) + +static bool js_cc_IBlockInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_binding_set) + +static bool js_cc_IBlockInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_binding_get) + +static bool js_cc_IBlockInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_name_set) + +static bool js_cc_IBlockInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_name_get) + +static bool js_cc_IBlockInfo_members_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->members, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_members_set) + +static bool js_cc_IBlockInfo_members_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->members, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->members, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_members_get) + +static bool js_cc_IBlockInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_stageFlags_set) + +static bool js_cc_IBlockInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_stageFlags_get) + +static bool js_cc_IBlockInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBlockInfo_defines_set) + +static bool js_cc_IBlockInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBlockInfo *arg1 = (cc::IBlockInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBlockInfo_defines_get) + +static bool js_new_cc_IBlockInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBlockInfo *result; + result = (cc::IBlockInfo *)new cc::IBlockInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBlockInfo, __jsb_cc_IBlockInfo_class, js_delete_cc_IBlockInfo) + +static bool js_delete_cc_IBlockInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBlockInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBlockInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("members", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->members), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBlockInfo(se::Object* obj) { + auto* cls = se::Class::create("IBlockInfo", obj, nullptr, _SE(js_new_cc_IBlockInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_IBlockInfo_binding_get), _SE(js_cc_IBlockInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IBlockInfo_name_get), _SE(js_cc_IBlockInfo_name_set)); + cls->defineProperty("members", _SE(js_cc_IBlockInfo_members_get), _SE(js_cc_IBlockInfo_members_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IBlockInfo_stageFlags_get), _SE(js_cc_IBlockInfo_stageFlags_set)); + cls->defineProperty("defines", _SE(js_cc_IBlockInfo_defines_get), _SE(js_cc_IBlockInfo_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBlockInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBlockInfo_proto = cls->getProto(); + __jsb_cc_IBlockInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISamplerTextureInfo_class = nullptr; +se::Object* __jsb_cc_ISamplerTextureInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISamplerTextureInfo) + +static bool js_cc_ISamplerTextureInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_binding_set) + +static bool js_cc_ISamplerTextureInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_binding_get) + +static bool js_cc_ISamplerTextureInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_name_set) + +static bool js_cc_ISamplerTextureInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_name_get) + +static bool js_cc_ISamplerTextureInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_type_set) + +static bool js_cc_ISamplerTextureInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_type_get) + +static bool js_cc_ISamplerTextureInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_count_set) + +static bool js_cc_ISamplerTextureInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_count_get) + +static bool js_cc_ISamplerTextureInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_stageFlags_set) + +static bool js_cc_ISamplerTextureInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_stageFlags_get) + +static bool js_cc_ISamplerTextureInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerTextureInfo_defines_set) + +static bool js_cc_ISamplerTextureInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerTextureInfo *arg1 = (cc::ISamplerTextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerTextureInfo_defines_get) + +static bool js_new_cc_ISamplerTextureInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ISamplerTextureInfo *result; + result = (cc::ISamplerTextureInfo *)new cc::ISamplerTextureInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ISamplerTextureInfo, __jsb_cc_ISamplerTextureInfo_class, js_delete_cc_ISamplerTextureInfo) + +static bool js_delete_cc_ISamplerTextureInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISamplerTextureInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerTextureInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_ISamplerTextureInfo(se::Object* obj) { + auto* cls = se::Class::create("ISamplerTextureInfo", obj, nullptr, _SE(js_new_cc_ISamplerTextureInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_ISamplerTextureInfo_binding_get), _SE(js_cc_ISamplerTextureInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_ISamplerTextureInfo_name_get), _SE(js_cc_ISamplerTextureInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_ISamplerTextureInfo_type_get), _SE(js_cc_ISamplerTextureInfo_type_set)); + cls->defineProperty("count", _SE(js_cc_ISamplerTextureInfo_count_get), _SE(js_cc_ISamplerTextureInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_ISamplerTextureInfo_stageFlags_get), _SE(js_cc_ISamplerTextureInfo_stageFlags_set)); + cls->defineProperty("defines", _SE(js_cc_ISamplerTextureInfo_defines_get), _SE(js_cc_ISamplerTextureInfo_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISamplerTextureInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISamplerTextureInfo_proto = cls->getProto(); + __jsb_cc_ISamplerTextureInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ITextureInfo_class = nullptr; +se::Object* __jsb_cc_ITextureInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ITextureInfo) + +static bool js_cc_ITextureInfo_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_set_set) + +static bool js_cc_ITextureInfo_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_set_get) + +static bool js_cc_ITextureInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_binding_set) + +static bool js_cc_ITextureInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_binding_get) + +static bool js_cc_ITextureInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_name_set) + +static bool js_cc_ITextureInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_name_get) + +static bool js_cc_ITextureInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_type_set) + +static bool js_cc_ITextureInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_type_get) + +static bool js_cc_ITextureInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_count_set) + +static bool js_cc_ITextureInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_count_get) + +static bool js_cc_ITextureInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ITextureInfo_stageFlags_set) + +static bool js_cc_ITextureInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ITextureInfo *arg1 = (cc::ITextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ITextureInfo_stageFlags_get) + +static bool js_new_cc_ITextureInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ITextureInfo *result; + result = (cc::ITextureInfo *)new cc::ITextureInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ITextureInfo, __jsb_cc_ITextureInfo_class, js_delete_cc_ITextureInfo) + +static bool js_delete_cc_ITextureInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ITextureInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_ITextureInfo(se::Object* obj) { + auto* cls = se::Class::create("ITextureInfo", obj, nullptr, _SE(js_new_cc_ITextureInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_ITextureInfo_set_get), _SE(js_cc_ITextureInfo_set_set)); + cls->defineProperty("binding", _SE(js_cc_ITextureInfo_binding_get), _SE(js_cc_ITextureInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_ITextureInfo_name_get), _SE(js_cc_ITextureInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_ITextureInfo_type_get), _SE(js_cc_ITextureInfo_type_set)); + cls->defineProperty("count", _SE(js_cc_ITextureInfo_count_get), _SE(js_cc_ITextureInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_ITextureInfo_stageFlags_get), _SE(js_cc_ITextureInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ITextureInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ITextureInfo_proto = cls->getProto(); + __jsb_cc_ITextureInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISamplerInfo_class = nullptr; +se::Object* __jsb_cc_ISamplerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISamplerInfo) + +static bool js_cc_ISamplerInfo_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_set_set) + +static bool js_cc_ISamplerInfo_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_set_get) + +static bool js_cc_ISamplerInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_binding_set) + +static bool js_cc_ISamplerInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_binding_get) + +static bool js_cc_ISamplerInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_name_set) + +static bool js_cc_ISamplerInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_name_get) + +static bool js_cc_ISamplerInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_count_set) + +static bool js_cc_ISamplerInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_count_get) + +static bool js_cc_ISamplerInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISamplerInfo_stageFlags_set) + +static bool js_cc_ISamplerInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISamplerInfo *arg1 = (cc::ISamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISamplerInfo_stageFlags_get) + +static bool js_new_cc_ISamplerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ISamplerInfo *result; + result = (cc::ISamplerInfo *)new cc::ISamplerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ISamplerInfo, __jsb_cc_ISamplerInfo_class, js_delete_cc_ISamplerInfo) + +static bool js_delete_cc_ISamplerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISamplerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_ISamplerInfo(se::Object* obj) { + auto* cls = se::Class::create("ISamplerInfo", obj, nullptr, _SE(js_new_cc_ISamplerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_ISamplerInfo_set_get), _SE(js_cc_ISamplerInfo_set_set)); + cls->defineProperty("binding", _SE(js_cc_ISamplerInfo_binding_get), _SE(js_cc_ISamplerInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_ISamplerInfo_name_get), _SE(js_cc_ISamplerInfo_name_set)); + cls->defineProperty("count", _SE(js_cc_ISamplerInfo_count_get), _SE(js_cc_ISamplerInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_ISamplerInfo_stageFlags_get), _SE(js_cc_ISamplerInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISamplerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISamplerInfo_proto = cls->getProto(); + __jsb_cc_ISamplerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBufferInfo_class = nullptr; +se::Object* __jsb_cc_IBufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBufferInfo) + +static bool js_cc_IBufferInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_binding_set) + +static bool js_cc_IBufferInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_binding_get) + +static bool js_cc_IBufferInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_name_set) + +static bool js_cc_IBufferInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_name_get) + +static bool js_cc_IBufferInfo_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_memoryAccess_set) + +static bool js_cc_IBufferInfo_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_memoryAccess_get) + +static bool js_cc_IBufferInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBufferInfo_stageFlags_set) + +static bool js_cc_IBufferInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBufferInfo *arg1 = (cc::IBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBufferInfo_stageFlags_get) + +static bool js_new_cc_IBufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBufferInfo *result; + result = (cc::IBufferInfo *)new cc::IBufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBufferInfo, __jsb_cc_IBufferInfo_class, js_delete_cc_IBufferInfo) + +static bool js_delete_cc_IBufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBufferInfo(se::Object* obj) { + auto* cls = se::Class::create("IBufferInfo", obj, nullptr, _SE(js_new_cc_IBufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_IBufferInfo_binding_get), _SE(js_cc_IBufferInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IBufferInfo_name_get), _SE(js_cc_IBufferInfo_name_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_IBufferInfo_memoryAccess_get), _SE(js_cc_IBufferInfo_memoryAccess_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IBufferInfo_stageFlags_get), _SE(js_cc_IBufferInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBufferInfo_proto = cls->getProto(); + __jsb_cc_IBufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IImageInfo_class = nullptr; +se::Object* __jsb_cc_IImageInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IImageInfo) + +static bool js_cc_IImageInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_binding_set) + +static bool js_cc_IImageInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_binding_get) + +static bool js_cc_IImageInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_name_set) + +static bool js_cc_IImageInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_name_get) + +static bool js_cc_IImageInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_type_set) + +static bool js_cc_IImageInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_type_get) + +static bool js_cc_IImageInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_count_set) + +static bool js_cc_IImageInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_count_get) + +static bool js_cc_IImageInfo_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_memoryAccess_set) + +static bool js_cc_IImageInfo_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_memoryAccess_get) + +static bool js_cc_IImageInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IImageInfo_stageFlags_set) + +static bool js_cc_IImageInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IImageInfo *arg1 = (cc::IImageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IImageInfo_stageFlags_get) + +static bool js_new_cc_IImageInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IImageInfo *result; + result = (cc::IImageInfo *)new cc::IImageInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IImageInfo, __jsb_cc_IImageInfo_class, js_delete_cc_IImageInfo) + +static bool js_delete_cc_IImageInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IImageInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IImageInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_IImageInfo(se::Object* obj) { + auto* cls = se::Class::create("IImageInfo", obj, nullptr, _SE(js_new_cc_IImageInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_IImageInfo_binding_get), _SE(js_cc_IImageInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IImageInfo_name_get), _SE(js_cc_IImageInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_IImageInfo_type_get), _SE(js_cc_IImageInfo_type_set)); + cls->defineProperty("count", _SE(js_cc_IImageInfo_count_get), _SE(js_cc_IImageInfo_count_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_IImageInfo_memoryAccess_get), _SE(js_cc_IImageInfo_memoryAccess_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IImageInfo_stageFlags_get), _SE(js_cc_IImageInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IImageInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IImageInfo_proto = cls->getProto(); + __jsb_cc_IImageInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IInputAttachmentInfo_class = nullptr; +se::Object* __jsb_cc_IInputAttachmentInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IInputAttachmentInfo) + +static bool js_cc_IInputAttachmentInfo_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_set_set) + +static bool js_cc_IInputAttachmentInfo_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_set_get) + +static bool js_cc_IInputAttachmentInfo_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_binding_set) + +static bool js_cc_IInputAttachmentInfo_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_binding_get) + +static bool js_cc_IInputAttachmentInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_name_set) + +static bool js_cc_IInputAttachmentInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_name_get) + +static bool js_cc_IInputAttachmentInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_count_set) + +static bool js_cc_IInputAttachmentInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_count_get) + +static bool js_cc_IInputAttachmentInfo_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IInputAttachmentInfo_stageFlags_set) + +static bool js_cc_IInputAttachmentInfo_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IInputAttachmentInfo *arg1 = (cc::IInputAttachmentInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IInputAttachmentInfo_stageFlags_get) + +static bool js_new_cc_IInputAttachmentInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IInputAttachmentInfo *result; + result = (cc::IInputAttachmentInfo *)new cc::IInputAttachmentInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IInputAttachmentInfo, __jsb_cc_IInputAttachmentInfo_class, js_delete_cc_IInputAttachmentInfo) + +static bool js_delete_cc_IInputAttachmentInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IInputAttachmentInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IInputAttachmentInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + return ok; +} + + +bool js_register_cc_IInputAttachmentInfo(se::Object* obj) { + auto* cls = se::Class::create("IInputAttachmentInfo", obj, nullptr, _SE(js_new_cc_IInputAttachmentInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_IInputAttachmentInfo_set_get), _SE(js_cc_IInputAttachmentInfo_set_set)); + cls->defineProperty("binding", _SE(js_cc_IInputAttachmentInfo_binding_get), _SE(js_cc_IInputAttachmentInfo_binding_set)); + cls->defineProperty("name", _SE(js_cc_IInputAttachmentInfo_name_get), _SE(js_cc_IInputAttachmentInfo_name_set)); + cls->defineProperty("count", _SE(js_cc_IInputAttachmentInfo_count_get), _SE(js_cc_IInputAttachmentInfo_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_IInputAttachmentInfo_stageFlags_get), _SE(js_cc_IInputAttachmentInfo_stageFlags_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IInputAttachmentInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IInputAttachmentInfo_proto = cls->getProto(); + __jsb_cc_IInputAttachmentInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IAttributeInfo_class = nullptr; +se::Object* __jsb_cc_IAttributeInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IAttributeInfo) + +static bool js_cc_IAttributeInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_name_set) + +static bool js_cc_IAttributeInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_name_get) + +static bool js_cc_IAttributeInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_format_set) + +static bool js_cc_IAttributeInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_format_get) + +static bool js_cc_IAttributeInfo_isNormalized_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isNormalized); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_isNormalized_set) + +static bool js_cc_IAttributeInfo_isNormalized_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isNormalized, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_isNormalized_get) + +static bool js_cc_IAttributeInfo_stream_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stream, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_stream_set) + +static bool js_cc_IAttributeInfo_stream_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stream, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_stream_get) + +static bool js_cc_IAttributeInfo_isInstanced_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isInstanced); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_isInstanced_set) + +static bool js_cc_IAttributeInfo_isInstanced_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isInstanced, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_isInstanced_get) + +static bool js_cc_IAttributeInfo_location_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->location, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_location_set) + +static bool js_cc_IAttributeInfo_location_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->location, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_location_get) + +static bool js_cc_IAttributeInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IAttributeInfo_defines_set) + +static bool js_cc_IAttributeInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IAttributeInfo *arg1 = (cc::IAttributeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IAttributeInfo_defines_get) + +static bool js_new_cc_IAttributeInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IAttributeInfo *result; + result = (cc::IAttributeInfo *)new cc::IAttributeInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IAttributeInfo, __jsb_cc_IAttributeInfo_class, js_delete_cc_IAttributeInfo) + +static bool js_delete_cc_IAttributeInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IAttributeInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IAttributeInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("isNormalized", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isNormalized), ctx); + } + + + json->getProperty("stream", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stream), ctx); + } + + + json->getProperty("isInstanced", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isInstanced), ctx); + } + + + json->getProperty("location", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->location), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_IAttributeInfo(se::Object* obj) { + auto* cls = se::Class::create("IAttributeInfo", obj, nullptr, _SE(js_new_cc_IAttributeInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IAttributeInfo_name_get), _SE(js_cc_IAttributeInfo_name_set)); + cls->defineProperty("format", _SE(js_cc_IAttributeInfo_format_get), _SE(js_cc_IAttributeInfo_format_set)); + cls->defineProperty("isNormalized", _SE(js_cc_IAttributeInfo_isNormalized_get), _SE(js_cc_IAttributeInfo_isNormalized_set)); + cls->defineProperty("stream", _SE(js_cc_IAttributeInfo_stream_get), _SE(js_cc_IAttributeInfo_stream_set)); + cls->defineProperty("isInstanced", _SE(js_cc_IAttributeInfo_isInstanced_get), _SE(js_cc_IAttributeInfo_isInstanced_set)); + cls->defineProperty("location", _SE(js_cc_IAttributeInfo_location_get), _SE(js_cc_IAttributeInfo_location_set)); + cls->defineProperty("defines", _SE(js_cc_IAttributeInfo_defines_get), _SE(js_cc_IAttributeInfo_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IAttributeInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IAttributeInfo_proto = cls->getProto(); + __jsb_cc_IAttributeInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDefineInfo_class = nullptr; +se::Object* __jsb_cc_IDefineInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDefineInfo) + +static bool js_cc_IDefineInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_name_set) + +static bool js_cc_IDefineInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_name_get) + +static bool js_cc_IDefineInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_type_set) + +static bool js_cc_IDefineInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_type_get) + +static bool js_cc_IDefineInfo_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->range, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_range_set) + +static bool js_cc_IDefineInfo_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->range, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->range, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_range_get) + +static bool js_cc_IDefineInfo_options_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->options, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_options_set) + +static bool js_cc_IDefineInfo_options_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->options, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->options, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_options_get) + +static bool js_cc_IDefineInfo_defaultVal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defaultVal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_defaultVal_set) + +static bool js_cc_IDefineInfo_defaultVal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defaultVal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defaultVal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_defaultVal_get) + +static bool js_cc_IDefineInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_defines_set) + +static bool js_cc_IDefineInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_defines_get) + +static bool js_cc_IDefineInfo_editor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->editor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineInfo_editor_set) + +static bool js_cc_IDefineInfo_editor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineInfo *arg1 = (cc::IDefineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->editor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->editor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineInfo_editor_get) + +static bool js_new_cc_IDefineInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDefineInfo *result; + result = (cc::IDefineInfo *)new cc::IDefineInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDefineInfo, __jsb_cc_IDefineInfo_class, js_delete_cc_IDefineInfo) + +static bool js_delete_cc_IDefineInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDefineInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("range", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->range), ctx); + } + + + json->getProperty("options", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->options), ctx); + } + + + json->getProperty("defaultVal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defaultVal), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("editor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->editor), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDefineInfo(se::Object* obj) { + auto* cls = se::Class::create("IDefineInfo", obj, nullptr, _SE(js_new_cc_IDefineInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IDefineInfo_name_get), _SE(js_cc_IDefineInfo_name_set)); + cls->defineProperty("type", _SE(js_cc_IDefineInfo_type_get), _SE(js_cc_IDefineInfo_type_set)); + cls->defineProperty("range", _SE(js_cc_IDefineInfo_range_get), _SE(js_cc_IDefineInfo_range_set)); + cls->defineProperty("options", _SE(js_cc_IDefineInfo_options_get), _SE(js_cc_IDefineInfo_options_set)); + cls->defineProperty("defaultVal", _SE(js_cc_IDefineInfo_defaultVal_get), _SE(js_cc_IDefineInfo_defaultVal_set)); + cls->defineProperty("defines", _SE(js_cc_IDefineInfo_defines_get), _SE(js_cc_IDefineInfo_defines_set)); + cls->defineProperty("editor", _SE(js_cc_IDefineInfo_editor_get), _SE(js_cc_IDefineInfo_editor_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDefineInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDefineInfo_proto = cls->getProto(); + __jsb_cc_IDefineInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBuiltin_class = nullptr; +se::Object* __jsb_cc_IBuiltin_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBuiltin) + +static bool js_cc_IBuiltin_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltin_name_set) + +static bool js_cc_IBuiltin_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltin_name_get) + +static bool js_cc_IBuiltin_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltin_defines_set) + +static bool js_cc_IBuiltin_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltin *arg1 = (cc::IBuiltin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltin_defines_get) + +static bool js_new_cc_IBuiltin(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBuiltin *result; + result = (cc::IBuiltin *)new cc::IBuiltin(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBuiltin, __jsb_cc_IBuiltin_class, js_delete_cc_IBuiltin) + +static bool js_delete_cc_IBuiltin(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBuiltin) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltin * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBuiltin(se::Object* obj) { + auto* cls = se::Class::create("IBuiltin", obj, nullptr, _SE(js_new_cc_IBuiltin)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IBuiltin_name_get), _SE(js_cc_IBuiltin_name_set)); + cls->defineProperty("defines", _SE(js_cc_IBuiltin_defines_get), _SE(js_cc_IBuiltin_defines_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBuiltin)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBuiltin_proto = cls->getProto(); + __jsb_cc_IBuiltin_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBuiltinInfo_class = nullptr; +se::Object* __jsb_cc_IBuiltinInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBuiltinInfo) + +static bool js_cc_IBuiltinInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_buffers_set) + +static bool js_cc_IBuiltinInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_buffers_get) + +static bool js_cc_IBuiltinInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_blocks_set) + +static bool js_cc_IBuiltinInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_blocks_get) + +static bool js_cc_IBuiltinInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_samplerTextures_set) + +static bool js_cc_IBuiltinInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_samplerTextures_get) + +static bool js_cc_IBuiltinInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltinInfo_images_set) + +static bool js_cc_IBuiltinInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltinInfo *arg1 = (cc::IBuiltinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltinInfo_images_get) + +static bool js_new_cc_IBuiltinInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBuiltinInfo *result; + result = (cc::IBuiltinInfo *)new cc::IBuiltinInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBuiltinInfo, __jsb_cc_IBuiltinInfo_class, js_delete_cc_IBuiltinInfo) + +static bool js_delete_cc_IBuiltinInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBuiltinInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltinInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBuiltinInfo(se::Object* obj) { + auto* cls = se::Class::create("IBuiltinInfo", obj, nullptr, _SE(js_new_cc_IBuiltinInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffers", _SE(js_cc_IBuiltinInfo_buffers_get), _SE(js_cc_IBuiltinInfo_buffers_set)); + cls->defineProperty("blocks", _SE(js_cc_IBuiltinInfo_blocks_get), _SE(js_cc_IBuiltinInfo_blocks_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_IBuiltinInfo_samplerTextures_get), _SE(js_cc_IBuiltinInfo_samplerTextures_set)); + cls->defineProperty("images", _SE(js_cc_IBuiltinInfo_images_get), _SE(js_cc_IBuiltinInfo_images_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBuiltinInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBuiltinInfo_proto = cls->getProto(); + __jsb_cc_IBuiltinInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IBuiltins_class = nullptr; +se::Object* __jsb_cc_IBuiltins_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IBuiltins) + +static bool js_cc_IBuiltins_globals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->globals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltins_globals_set) + +static bool js_cc_IBuiltins_globals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->globals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->globals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltins_globals_get) + +static bool js_cc_IBuiltins_locals_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->locals, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltins_locals_set) + +static bool js_cc_IBuiltins_locals_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->locals, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->locals, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltins_locals_get) + +static bool js_cc_IBuiltins_statistics_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->statistics, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IBuiltins_statistics_set) + +static bool js_cc_IBuiltins_statistics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IBuiltins *arg1 = (cc::IBuiltins *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->statistics, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->statistics, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IBuiltins_statistics_get) + +static bool js_new_cc_IBuiltins(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IBuiltins *result; + result = (cc::IBuiltins *)new cc::IBuiltins(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IBuiltins, __jsb_cc_IBuiltins_class, js_delete_cc_IBuiltins) + +static bool js_delete_cc_IBuiltins(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IBuiltins) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltins * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("globals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->globals), ctx); + } + + + json->getProperty("locals", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->locals), ctx); + } + + + json->getProperty("statistics", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->statistics), ctx); + } + + + return ok; +} + + +bool js_register_cc_IBuiltins(se::Object* obj) { + auto* cls = se::Class::create("IBuiltins", obj, nullptr, _SE(js_new_cc_IBuiltins)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("globals", _SE(js_cc_IBuiltins_globals_get), _SE(js_cc_IBuiltins_globals_set)); + cls->defineProperty("locals", _SE(js_cc_IBuiltins_locals_get), _SE(js_cc_IBuiltins_locals_set)); + cls->defineProperty("statistics", _SE(js_cc_IBuiltins_statistics_get), _SE(js_cc_IBuiltins_statistics_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IBuiltins)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IBuiltins_proto = cls->getProto(); + __jsb_cc_IBuiltins_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDescriptorInfo_class = nullptr; +se::Object* __jsb_cc_IDescriptorInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDescriptorInfo) + +static bool js_cc_IDescriptorInfo_rate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rate, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_rate_set) + +static bool js_cc_IDescriptorInfo_rate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_rate_get) + +static bool js_cc_IDescriptorInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_blocks_set) + +static bool js_cc_IDescriptorInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_blocks_get) + +static bool js_cc_IDescriptorInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_samplerTextures_set) + +static bool js_cc_IDescriptorInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_samplerTextures_get) + +static bool js_cc_IDescriptorInfo_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_samplers_set) + +static bool js_cc_IDescriptorInfo_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_samplers_get) + +static bool js_cc_IDescriptorInfo_textures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_textures_set) + +static bool js_cc_IDescriptorInfo_textures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_textures_get) + +static bool js_cc_IDescriptorInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_buffers_set) + +static bool js_cc_IDescriptorInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_buffers_get) + +static bool js_cc_IDescriptorInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_images_set) + +static bool js_cc_IDescriptorInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_images_get) + +static bool js_cc_IDescriptorInfo_subpassInputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassInputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDescriptorInfo_subpassInputs_set) + +static bool js_cc_IDescriptorInfo_subpassInputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDescriptorInfo *arg1 = (cc::IDescriptorInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassInputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpassInputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDescriptorInfo_subpassInputs_get) + +static bool js_new_cc_IDescriptorInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDescriptorInfo *result; + result = (cc::IDescriptorInfo *)new cc::IDescriptorInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDescriptorInfo, __jsb_cc_IDescriptorInfo_class, js_delete_cc_IDescriptorInfo) + +static bool js_delete_cc_IDescriptorInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDescriptorInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDescriptorInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("rate", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rate), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("textures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textures), ctx); + } + + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + json->getProperty("subpassInputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassInputs), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDescriptorInfo(se::Object* obj) { + auto* cls = se::Class::create("IDescriptorInfo", obj, nullptr, _SE(js_new_cc_IDescriptorInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("rate", _SE(js_cc_IDescriptorInfo_rate_get), _SE(js_cc_IDescriptorInfo_rate_set)); + cls->defineProperty("blocks", _SE(js_cc_IDescriptorInfo_blocks_get), _SE(js_cc_IDescriptorInfo_blocks_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_IDescriptorInfo_samplerTextures_get), _SE(js_cc_IDescriptorInfo_samplerTextures_set)); + cls->defineProperty("samplers", _SE(js_cc_IDescriptorInfo_samplers_get), _SE(js_cc_IDescriptorInfo_samplers_set)); + cls->defineProperty("textures", _SE(js_cc_IDescriptorInfo_textures_get), _SE(js_cc_IDescriptorInfo_textures_set)); + cls->defineProperty("buffers", _SE(js_cc_IDescriptorInfo_buffers_get), _SE(js_cc_IDescriptorInfo_buffers_set)); + cls->defineProperty("images", _SE(js_cc_IDescriptorInfo_images_get), _SE(js_cc_IDescriptorInfo_images_set)); + cls->defineProperty("subpassInputs", _SE(js_cc_IDescriptorInfo_subpassInputs_get), _SE(js_cc_IDescriptorInfo_subpassInputs_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDescriptorInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDescriptorInfo_proto = cls->getProto(); + __jsb_cc_IDescriptorInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IShaderSource_class = nullptr; +se::Object* __jsb_cc_IShaderSource_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IShaderSource) + +static bool js_cc_IShaderSource_vert_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vert, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderSource_vert_set) + +static bool js_cc_IShaderSource_vert_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vert, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vert, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderSource_vert_get) + +static bool js_cc_IShaderSource_frag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderSource_frag_set) + +static bool js_cc_IShaderSource_frag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frag, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->frag, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderSource_frag_get) + +static bool js_cc_IShaderSource_compute_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compute, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderSource_compute_set) + +static bool js_cc_IShaderSource_compute_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderSource *arg1 = (cc::IShaderSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compute, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->compute, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderSource_compute_get) + +static bool js_new_cc_IShaderSource(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IShaderSource *result; + result = (cc::IShaderSource *)new cc::IShaderSource(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IShaderSource, __jsb_cc_IShaderSource_class, js_delete_cc_IShaderSource) + +static bool js_delete_cc_IShaderSource(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IShaderSource) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderSource * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vert", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vert), ctx); + } + + + json->getProperty("frag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frag), ctx); + } + + + json->getProperty("compute", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compute), ctx); + } + + + return ok; +} + + +bool js_register_cc_IShaderSource(se::Object* obj) { + auto* cls = se::Class::create("IShaderSource", obj, nullptr, _SE(js_new_cc_IShaderSource)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vert", _SE(js_cc_IShaderSource_vert_get), _SE(js_cc_IShaderSource_vert_set)); + cls->defineProperty("frag", _SE(js_cc_IShaderSource_frag_get), _SE(js_cc_IShaderSource_frag_set)); + cls->defineProperty("compute", _SE(js_cc_IShaderSource_compute_get), _SE(js_cc_IShaderSource_compute_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IShaderSource)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IShaderSource_proto = cls->getProto(); + __jsb_cc_IShaderSource_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IShaderInfo_class = nullptr; +se::Object* __jsb_cc_IShaderInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IShaderInfo) + +static bool js_cc_IShaderInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_name_set) + +static bool js_cc_IShaderInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_name_get) + +static bool js_cc_IShaderInfo_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_hash_set) + +static bool js_cc_IShaderInfo_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hash, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->hash, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_hash_get) + +static bool js_cc_IShaderInfo_glsl4_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->glsl4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_glsl4_set) + +static bool js_cc_IShaderInfo_glsl4_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->glsl4, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->glsl4, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_glsl4_get) + +static bool js_cc_IShaderInfo_glsl3_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->glsl3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_glsl3_set) + +static bool js_cc_IShaderInfo_glsl3_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->glsl3, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->glsl3, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_glsl3_get) + +static bool js_cc_IShaderInfo_glsl1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->glsl1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_glsl1_set) + +static bool js_cc_IShaderInfo_glsl1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->glsl1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->glsl1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_glsl1_get) + +static bool js_cc_IShaderInfo_builtins_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->builtins, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_builtins_set) + +static bool js_cc_IShaderInfo_builtins_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->builtins, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->builtins, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_builtins_get) + +static bool js_cc_IShaderInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_defines_set) + +static bool js_cc_IShaderInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_defines_get) + +static bool js_cc_IShaderInfo_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_attributes_set) + +static bool js_cc_IShaderInfo_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_attributes_get) + +static bool js_cc_IShaderInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_blocks_set) + +static bool js_cc_IShaderInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_blocks_get) + +static bool js_cc_IShaderInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_samplerTextures_set) + +static bool js_cc_IShaderInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_samplerTextures_get) + +static bool js_cc_IShaderInfo_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_samplers_set) + +static bool js_cc_IShaderInfo_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_samplers_get) + +static bool js_cc_IShaderInfo_textures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_textures_set) + +static bool js_cc_IShaderInfo_textures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_textures_get) + +static bool js_cc_IShaderInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_buffers_set) + +static bool js_cc_IShaderInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_buffers_get) + +static bool js_cc_IShaderInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_images_set) + +static bool js_cc_IShaderInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_images_get) + +static bool js_cc_IShaderInfo_subpassInputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassInputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_subpassInputs_set) + +static bool js_cc_IShaderInfo_subpassInputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassInputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpassInputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_subpassInputs_get) + +static bool js_cc_IShaderInfo_descriptors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->descriptors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IShaderInfo_descriptors_set) + +static bool js_cc_IShaderInfo_descriptors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->descriptors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->descriptors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IShaderInfo_descriptors_get) + +static bool js_cc_IShaderInfo_getSource__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::IShaderSource *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::IShaderSource *)((cc::IShaderInfo const *)arg1)->getSource((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; +} + +static bool js_cc_IShaderInfo_getSource__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IShaderInfo *arg1 = (cc::IShaderInfo *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::IShaderSource *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::IShaderSource *)(arg1)->getSource((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; +} + +static bool js_cc_IShaderInfo_getSource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_IShaderInfo_getSource__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_IShaderInfo_getSource__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_IShaderInfo_getSource) + +static bool js_new_cc_IShaderInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IShaderInfo *result; + result = (cc::IShaderInfo *)new cc::IShaderInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IShaderInfo, __jsb_cc_IShaderInfo_class, js_delete_cc_IShaderInfo) + +static bool js_delete_cc_IShaderInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IShaderInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("hash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hash), ctx); + } + + + json->getProperty("glsl4", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->glsl4), ctx); + } + + + json->getProperty("glsl3", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->glsl3), ctx); + } + + + json->getProperty("glsl1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->glsl1), ctx); + } + + + json->getProperty("builtins", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->builtins), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("textures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textures), ctx); + } + + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + json->getProperty("subpassInputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassInputs), ctx); + } + + + json->getProperty("descriptors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->descriptors), ctx); + } + + + return ok; +} + + +bool js_register_cc_IShaderInfo(se::Object* obj) { + auto* cls = se::Class::create("IShaderInfo", obj, nullptr, _SE(js_new_cc_IShaderInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IShaderInfo_name_get), _SE(js_cc_IShaderInfo_name_set)); + cls->defineProperty("hash", _SE(js_cc_IShaderInfo_hash_get), _SE(js_cc_IShaderInfo_hash_set)); + cls->defineProperty("glsl4", _SE(js_cc_IShaderInfo_glsl4_get), _SE(js_cc_IShaderInfo_glsl4_set)); + cls->defineProperty("glsl3", _SE(js_cc_IShaderInfo_glsl3_get), _SE(js_cc_IShaderInfo_glsl3_set)); + cls->defineProperty("glsl1", _SE(js_cc_IShaderInfo_glsl1_get), _SE(js_cc_IShaderInfo_glsl1_set)); + cls->defineProperty("builtins", _SE(js_cc_IShaderInfo_builtins_get), _SE(js_cc_IShaderInfo_builtins_set)); + cls->defineProperty("defines", _SE(js_cc_IShaderInfo_defines_get), _SE(js_cc_IShaderInfo_defines_set)); + cls->defineProperty("attributes", _SE(js_cc_IShaderInfo_attributes_get), _SE(js_cc_IShaderInfo_attributes_set)); + cls->defineProperty("blocks", _SE(js_cc_IShaderInfo_blocks_get), _SE(js_cc_IShaderInfo_blocks_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_IShaderInfo_samplerTextures_get), _SE(js_cc_IShaderInfo_samplerTextures_set)); + cls->defineProperty("samplers", _SE(js_cc_IShaderInfo_samplers_get), _SE(js_cc_IShaderInfo_samplers_set)); + cls->defineProperty("textures", _SE(js_cc_IShaderInfo_textures_get), _SE(js_cc_IShaderInfo_textures_set)); + cls->defineProperty("buffers", _SE(js_cc_IShaderInfo_buffers_get), _SE(js_cc_IShaderInfo_buffers_set)); + cls->defineProperty("images", _SE(js_cc_IShaderInfo_images_get), _SE(js_cc_IShaderInfo_images_set)); + cls->defineProperty("subpassInputs", _SE(js_cc_IShaderInfo_subpassInputs_get), _SE(js_cc_IShaderInfo_subpassInputs_set)); + cls->defineProperty("descriptors", _SE(js_cc_IShaderInfo_descriptors_get), _SE(js_cc_IShaderInfo_descriptors_set)); + + cls->defineFunction("getSource", _SE(js_cc_IShaderInfo_getSource)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IShaderInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IShaderInfo_proto = cls->getProto(); + __jsb_cc_IShaderInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_EffectAsset_class = nullptr; +se::Object* __jsb_cc_EffectAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_EffectAsset) + +static bool js_new_cc_EffectAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::EffectAsset *result; + result = (cc::EffectAsset *)new cc::EffectAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_EffectAsset, __jsb_cc_EffectAsset_class, js_delete_cc_EffectAsset) + +static bool js_delete_cc_EffectAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_EffectAsset) + +static bool js_cc_EffectAsset_cpp_keyword_register_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) 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::EffectAsset::registerAsset(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_EffectAsset_cpp_keyword_register_static) + +static bool js_cc_EffectAsset_remove_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + cc::EffectAsset::remove((ccstd::string const &)*arg1); + + + return true; +} + +static bool js_cc_EffectAsset_remove_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::EffectAsset::remove(arg1); + + + return true; +} + +static bool js_cc_EffectAsset_remove_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_EffectAsset_remove_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_EffectAsset_remove_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_EffectAsset_remove_static) + +static bool js_cc_EffectAsset_get_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::EffectAsset *result = 0 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::EffectAsset *)cc::EffectAsset::get((ccstd::string const &)*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_FUNC(js_cc_EffectAsset_get_static) + +static bool js_cc_EffectAsset_getAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset::RegisteredEffectAssetMap *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::EffectAsset::RegisteredEffectAssetMap *) &cc::EffectAsset::getAll(); + + 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_EffectAsset_getAll_static) + +static bool js_cc_EffectAsset_isLayoutValid_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)cc::EffectAsset::isLayoutValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_EffectAsset_isLayoutValid_static) + +static bool js_cc_EffectAsset_setLayoutValid_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::EffectAsset::setLayoutValid(); + + + return true; +} +SE_BIND_FUNC(js_cc_EffectAsset_setLayoutValid_static) + +static bool js_cc_EffectAsset_hideInEditor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hideInEditor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_hideInEditor_set) + +static bool js_cc_EffectAsset_hideInEditor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hideInEditor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_EffectAsset_hideInEditor_get) + +static bool js_cc_EffectAsset_techniques_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::ITechniqueInfo > *arg2 = 0 ; + ccstd::vector< cc::ITechniqueInfo > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_EffectAsset_techniques_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_techniques_set) + +static bool js_cc_EffectAsset_techniques_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::ITechniqueInfo > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::ITechniqueInfo > *) &cc_EffectAsset_techniques_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_EffectAsset_techniques_get) + +static bool js_cc_EffectAsset_shaders_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IShaderInfo > *arg2 = 0 ; + ccstd::vector< cc::IShaderInfo > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_EffectAsset_shaders_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_shaders_set) + +static bool js_cc_EffectAsset_shaders_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IShaderInfo > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IShaderInfo > *) &cc_EffectAsset_shaders_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_EffectAsset_shaders_get) + +static bool js_cc_EffectAsset_combinations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IPreCompileInfo > *arg2 = 0 ; + ccstd::vector< cc::IPreCompileInfo > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_EffectAsset_combinations_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_EffectAsset_combinations_set) + +static bool js_cc_EffectAsset_combinations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::EffectAsset *arg1 = (cc::EffectAsset *) NULL ; + ccstd::vector< cc::IPreCompileInfo > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IPreCompileInfo > *) &cc_EffectAsset_combinations_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_EffectAsset_combinations_get) + +bool js_register_cc_EffectAsset(se::Object* obj) { + auto* cls = se::Class::create("EffectAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_EffectAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hideInEditor", _SE(js_cc_EffectAsset_hideInEditor_get), _SE(js_cc_EffectAsset_hideInEditor_set)); + cls->defineProperty("techniques", _SE(js_cc_EffectAsset_techniques_get), _SE(js_cc_EffectAsset_techniques_set)); + cls->defineProperty("shaders", _SE(js_cc_EffectAsset_shaders_get), _SE(js_cc_EffectAsset_shaders_set)); + cls->defineProperty("combinations", _SE(js_cc_EffectAsset_combinations_get), _SE(js_cc_EffectAsset_combinations_set)); + + + + cls->defineStaticFunction("register", _SE(js_cc_EffectAsset_cpp_keyword_register_static)); + cls->defineStaticFunction("remove", _SE(js_cc_EffectAsset_remove_static)); + cls->defineStaticFunction("get", _SE(js_cc_EffectAsset_get_static)); + cls->defineStaticFunction("getAll", _SE(js_cc_EffectAsset_getAll_static)); + cls->defineStaticFunction("isLayoutValid", _SE(js_cc_EffectAsset_isLayoutValid_static)); + cls->defineStaticFunction("setLayoutValid", _SE(js_cc_EffectAsset_setLayoutValid_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_EffectAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_EffectAsset_proto = cls->getProto(); + __jsb_cc_EffectAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMemoryImageSource_class = nullptr; +se::Object* __jsb_cc_IMemoryImageSource_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMemoryImageSource) + +static bool js_cc_IMemoryImageSource_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_width_set) + +static bool js_cc_IMemoryImageSource_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_width_get) + +static bool js_cc_IMemoryImageSource_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_height_set) + +static bool js_cc_IMemoryImageSource_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_height_get) + +static bool js_cc_IMemoryImageSource_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_format_set) + +static bool js_cc_IMemoryImageSource_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_format_get) + +static bool js_cc_IMemoryImageSource_mipmapLevelDataSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipmapLevelDataSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMemoryImageSource_mipmapLevelDataSize_set) + +static bool js_cc_IMemoryImageSource_mipmapLevelDataSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMemoryImageSource *arg1 = (cc::IMemoryImageSource *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipmapLevelDataSize, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipmapLevelDataSize, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMemoryImageSource_mipmapLevelDataSize_get) + +static bool js_new_cc_IMemoryImageSource(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMemoryImageSource *result; + result = (cc::IMemoryImageSource *)new cc::IMemoryImageSource(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMemoryImageSource, __jsb_cc_IMemoryImageSource_class, js_delete_cc_IMemoryImageSource) + +static bool js_delete_cc_IMemoryImageSource(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMemoryImageSource) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMemoryImageSource * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("mipmapLevelDataSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipmapLevelDataSize), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMemoryImageSource(se::Object* obj) { + auto* cls = se::Class::create("IMemoryImageSource", obj, nullptr, _SE(js_new_cc_IMemoryImageSource)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_IMemoryImageSource_width_get), _SE(js_cc_IMemoryImageSource_width_set)); + cls->defineProperty("height", _SE(js_cc_IMemoryImageSource_height_get), _SE(js_cc_IMemoryImageSource_height_set)); + cls->defineProperty("format", _SE(js_cc_IMemoryImageSource_format_get), _SE(js_cc_IMemoryImageSource_format_set)); + cls->defineProperty("mipmapLevelDataSize", _SE(js_cc_IMemoryImageSource_mipmapLevelDataSize_get), _SE(js_cc_IMemoryImageSource_mipmapLevelDataSize_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMemoryImageSource)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMemoryImageSource_proto = cls->getProto(); + __jsb_cc_IMemoryImageSource_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ImageAsset_class = nullptr; +se::Object* __jsb_cc_ImageAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ImageAsset) + +static bool js_new_cc_ImageAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ImageAsset *result; + result = (cc::ImageAsset *)new cc::ImageAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ImageAsset, __jsb_cc_ImageAsset_class, js_delete_cc_ImageAsset) + +static bool js_delete_cc_ImageAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ImageAsset) + +static bool js_cc_ImageAsset_getData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint8_t *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(s); + if (nullptr == arg1) return true; + result = (uint8_t *)((cc::ImageAsset const *)arg1)->getData(); + + 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_ImageAsset_getData) + +static bool js_cc_ImageAsset_getWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ImageAsset const *)arg1)->getWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_getWidth) + +static bool js_cc_ImageAsset_getHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ImageAsset const *)arg1)->getHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_getHeight) + +static bool js_cc_ImageAsset_getMipmapLevelDataSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::vector< uint32_t > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< uint32_t > *) &((cc::ImageAsset const *)arg1)->getMipmapLevelDataSize(); + + 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_ImageAsset_getMipmapLevelDataSize) + +static bool js_cc_ImageAsset_isCompressed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::ImageAsset const *)arg1)->isCompressed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_isCompressed) + +static bool js_cc_ImageAsset_setWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setWidth) + +static bool js_cc_ImageAsset_setHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setHeight) + +static bool js_cc_ImageAsset_setNeedFreeData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setNeedFreeData(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setNeedFreeData) + +static bool js_cc_ImageAsset_setMipmapLevelDataSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::vector< uint32_t > *arg2 = 0 ; + ccstd::vector< uint32_t > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMipmapLevelDataSize((ccstd::vector< uint32_t > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setMipmapLevelDataSize) + +static bool js_cc_ImageAsset_setFixedFormat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::PixelFormat arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setFixedFormat(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_setFixedFormat) + +static bool js_cc_ImageAsset_isFormatFixed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::ImageAsset const *)arg1)->isFormatFixed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_isFormatFixed) + +static bool js_cc_ImageAsset_extractMipmap0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::IntrusivePtr< cc::ImageAsset > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->extractMipmap0(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_extractMipmap0) + +static bool js_cc_ImageAsset_extractMipmaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + std::vector< cc::IntrusivePtr< cc::ImageAsset > > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->extractMipmaps(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ImageAsset_extractMipmaps) + +static bool js_cc_ImageAsset_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::PixelFormat arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_ImageAsset_format_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ImageAsset_format_set) + +static bool js_cc_ImageAsset_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + cc::PixelFormat result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::PixelFormat)cc_ImageAsset_format_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_ImageAsset_format_get) + +static bool js_cc_ImageAsset_url_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ImageAsset_url_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ImageAsset_url_set) + +static bool js_cc_ImageAsset_url_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ImageAsset *arg1 = (cc::ImageAsset *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_ImageAsset_url_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_ImageAsset_url_get) + +bool js_register_cc_ImageAsset(se::Object* obj) { + auto* cls = se::Class::create("ImageAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_ImageAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("format", _SE(js_cc_ImageAsset_format_get), _SE(js_cc_ImageAsset_format_set)); + cls->defineProperty("url", _SE(js_cc_ImageAsset_url_get), _SE(js_cc_ImageAsset_url_set)); + + cls->defineFunction("getData", _SE(js_cc_ImageAsset_getData)); + cls->defineFunction("getWidth", _SE(js_cc_ImageAsset_getWidth)); + cls->defineFunction("getHeight", _SE(js_cc_ImageAsset_getHeight)); + cls->defineFunction("getMipmapLevelDataSize", _SE(js_cc_ImageAsset_getMipmapLevelDataSize)); + cls->defineFunction("isCompressed", _SE(js_cc_ImageAsset_isCompressed)); + cls->defineFunction("setWidth", _SE(js_cc_ImageAsset_setWidth)); + cls->defineFunction("setHeight", _SE(js_cc_ImageAsset_setHeight)); + cls->defineFunction("setNeedFreeData", _SE(js_cc_ImageAsset_setNeedFreeData)); + cls->defineFunction("setMipmapLevelDataSize", _SE(js_cc_ImageAsset_setMipmapLevelDataSize)); + cls->defineFunction("setFixedFormat", _SE(js_cc_ImageAsset_setFixedFormat)); + cls->defineFunction("isFormatFixed", _SE(js_cc_ImageAsset_isFormatFixed)); + cls->defineFunction("extractMipmap0", _SE(js_cc_ImageAsset_extractMipmap0)); + cls->defineFunction("extractMipmaps", _SE(js_cc_ImageAsset_extractMipmaps)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ImageAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ImageAsset_proto = cls->getProto(); + __jsb_cc_ImageAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SceneAsset_class = nullptr; +se::Object* __jsb_cc_SceneAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SceneAsset) + +static bool js_new_cc_SceneAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SceneAsset *result; + result = (cc::SceneAsset *)new cc::SceneAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SceneAsset, __jsb_cc_SceneAsset_class, js_delete_cc_SceneAsset) + +static bool js_delete_cc_SceneAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SceneAsset) + +static bool js_cc_SceneAsset_getScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneAsset *arg1 = (cc::SceneAsset *) NULL ; + cc::Scene *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(s); + if (nullptr == arg1) return true; + result = (cc::Scene *)((cc::SceneAsset const *)arg1)->getScene(); + + 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_SceneAsset_getScene) + +static bool js_cc_SceneAsset_setScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneAsset *arg1 = (cc::SceneAsset *) NULL ; + cc::Scene *arg2 = (cc::Scene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneAsset_setScene) + +bool js_register_cc_SceneAsset(se::Object* obj) { + auto* cls = se::Class::create("SceneAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_SceneAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getScene", _SE(js_cc_SceneAsset_getScene)); + cls->defineFunction("setScene", _SE(js_cc_SceneAsset_setScene)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SceneAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SceneAsset_proto = cls->getProto(); + __jsb_cc_SceneAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_TextAsset_class = nullptr; +se::Object* __jsb_cc_TextAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_TextAsset) + +static bool js_new_cc_TextAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::TextAsset *result; + result = (cc::TextAsset *)new cc::TextAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_TextAsset, __jsb_cc_TextAsset_class, js_delete_cc_TextAsset) + +static bool js_delete_cc_TextAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_TextAsset) + +static bool js_cc_TextAsset_text_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::TextAsset *arg1 = (cc::TextAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->text, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_TextAsset_text_set) + +static bool js_cc_TextAsset_text_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::TextAsset *arg1 = (cc::TextAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->text, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->text, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_TextAsset_text_get) + +bool js_register_cc_TextAsset(se::Object* obj) { + auto* cls = se::Class::create("TextAsset", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_TextAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("text", _SE(js_cc_TextAsset_text_get), _SE(js_cc_TextAsset_text_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_TextAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_TextAsset_proto = cls->getProto(); + __jsb_cc_TextAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMaterialInfo_class = nullptr; +se::Object* __jsb_cc_IMaterialInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMaterialInfo) + +static bool js_cc_IMaterialInfo_effectAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->effectAsset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_effectAsset_set) + +static bool js_cc_IMaterialInfo_effectAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->effectAsset, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->effectAsset, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_effectAsset_get) + +static bool js_cc_IMaterialInfo_effectName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->effectName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_effectName_set) + +static bool js_cc_IMaterialInfo_effectName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->effectName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->effectName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_effectName_get) + +static bool js_cc_IMaterialInfo_technique_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->technique, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_technique_set) + +static bool js_cc_IMaterialInfo_technique_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->technique, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->technique, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_technique_get) + +static bool js_cc_IMaterialInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_defines_set) + +static bool js_cc_IMaterialInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_defines_get) + +static bool js_cc_IMaterialInfo_states_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->states, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInfo_states_set) + +static bool js_cc_IMaterialInfo_states_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->states, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->states, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInfo_states_get) + +static bool js_cc_IMaterialInfo_isEmpty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInfo *arg1 = (cc::IMaterialInfo *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::IMaterialInfo const *)arg1)->isEmpty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_IMaterialInfo_isEmpty) + +static bool js_new_cc_IMaterialInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMaterialInfo *result; + result = (cc::IMaterialInfo *)new cc::IMaterialInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMaterialInfo, __jsb_cc_IMaterialInfo_class, js_delete_cc_IMaterialInfo) + +static bool js_delete_cc_IMaterialInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMaterialInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("effectAsset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->effectAsset), ctx); + } + + + json->getProperty("effectName", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->effectName), ctx); + } + + + json->getProperty("technique", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->technique), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("states", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->states), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMaterialInfo(se::Object* obj) { + auto* cls = se::Class::create("IMaterialInfo", obj, nullptr, _SE(js_new_cc_IMaterialInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("effectAsset", _SE(js_cc_IMaterialInfo_effectAsset_get), _SE(js_cc_IMaterialInfo_effectAsset_set)); + cls->defineProperty("effectName", _SE(js_cc_IMaterialInfo_effectName_get), _SE(js_cc_IMaterialInfo_effectName_set)); + cls->defineProperty("technique", _SE(js_cc_IMaterialInfo_technique_get), _SE(js_cc_IMaterialInfo_technique_set)); + cls->defineProperty("defines", _SE(js_cc_IMaterialInfo_defines_get), _SE(js_cc_IMaterialInfo_defines_set)); + cls->defineProperty("states", _SE(js_cc_IMaterialInfo_states_get), _SE(js_cc_IMaterialInfo_states_set)); + + cls->defineFunction("isEmpty", _SE(js_cc_IMaterialInfo_isEmpty)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMaterialInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMaterialInfo_proto = cls->getProto(); + __jsb_cc_IMaterialInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Material_class = nullptr; +se::Object* __jsb_cc_Material_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Material) + +static bool js_cc_Material_getHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::Material::getHashForMaterial(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_FUNC(js_cc_Material_getHash_static) + +static bool js_new_cc_Material(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Material *result; + result = (cc::Material *)new cc::Material(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Material, __jsb_cc_Material_class, js_delete_cc_Material) + +static bool js_delete_cc_Material(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Material) + +static bool js_cc_Material_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg2 = 0 ; + cc::IMaterialInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::IMaterialInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Material_initialize) + +static bool js_cc_Material_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg2 = 0 ; + cc::IMaterialInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::IMaterialInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Material_reset) + +static bool js_cc_Material_recompileShaders__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::MacroRecord *arg2 = 0 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2); + + + return true; +} + +static bool js_cc_Material_recompileShaders__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::MacroRecord *arg2 = 0 ; + index_t arg3 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_recompileShaders(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Material_recompileShaders__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_recompileShaders__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_recompileShaders) + +static bool js_cc_Material_overridePipelineStates__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::PassOverrides *arg2 = 0 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2); + + + return true; +} + +static bool js_cc_Material_overridePipelineStates__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::PassOverrides *arg2 = 0 ; + index_t arg3 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_overridePipelineStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Material_overridePipelineStates__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_overridePipelineStates__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_overridePipelineStates) + +static bool js_cc_Material_resetUniforms__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resetUniforms(arg2); + + + return true; +} + +static bool js_cc_Material_resetUniforms__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetUniforms(); + + + return true; +} + +static bool js_cc_Material_resetUniforms(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Material_resetUniforms__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Material_resetUniforms__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_resetUniforms) + +static bool js_cc_Material_setPropertyNull__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + index_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyNull((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyNull__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyNull((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_Material_setPropertyNull(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Material_setPropertyNull__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Material_setPropertyNull__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyNull) + +static bool js_cc_Material_setPropertyFloat32__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + float arg3 ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyFloat32((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + float arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyFloat32((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyFloat32__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyFloat32__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyFloat32) + +static bool js_cc_Material_setPropertyInt32__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + int32_t arg3 ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyInt32((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + int32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyInt32((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyInt32__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyInt32__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyInt32) + +static bool js_cc_Material_setPropertyVec2__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec2((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec2((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec2__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec2__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec2) + +static bool js_cc_Material_setPropertyVec3__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec3((ccstd::string const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec3((ccstd::string const &)*arg2,(cc::Vec3 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec3__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec3__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec3) + +static bool js_cc_Material_setPropertyVec4__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec4 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Vec4 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec4((ccstd::string const &)*arg2,(cc::Vec4 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec4 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec4 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec4((ccstd::string const &)*arg2,(cc::Vec4 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec4__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec4__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec4) + +static bool js_cc_Material_setPropertyColor__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Color *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Color temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyColor((ccstd::string const &)*arg2,(cc::Color const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyColor__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Color *arg3 = 0 ; + ccstd::string temp2 ; + cc::Color temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyColor((ccstd::string const &)*arg2,(cc::Color const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyColor__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyColor__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyColor) + +static bool js_cc_Material_setPropertyMat3__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat3 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Mat3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat3((ccstd::string const &)*arg2,(cc::Mat3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat3 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Mat3 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat3((ccstd::string const &)*arg2,(cc::Mat3 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat3__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat3__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat3) + +static bool js_cc_Material_setPropertyMat4__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat4 *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Mat4 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat4((ccstd::string const &)*arg2,(cc::Mat4 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Mat4 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Mat4 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat4((ccstd::string const &)*arg2,(cc::Mat4 const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat4__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat4__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat4) + +static bool js_cc_Material_setPropertyQuaternion__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Quaternion *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::Quaternion temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyQuaternion((ccstd::string const &)*arg2,(cc::Quaternion const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternion__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Quaternion *arg3 = 0 ; + ccstd::string temp2 ; + cc::Quaternion temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyQuaternion((ccstd::string const &)*arg2,(cc::Quaternion const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyQuaternion__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyQuaternion__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyQuaternion) + +static bool js_cc_Material_setPropertyTextureBase__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TextureBase *arg3 = (cc::TextureBase *) NULL ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyTextureBase((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBase__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TextureBase *arg3 = (cc::TextureBase *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyTextureBase((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBase(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyTextureBase__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyTextureBase__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyTextureBase) + +static bool js_cc_Material_setPropertyGFXTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + index_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyGFXTexture((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyGFXTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyGFXTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyGFXTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyGFXTexture) + +static bool js_cc_Material_setPropertyFloat32Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< float > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< float > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyFloat32Array((ccstd::string const &)*arg2,(ccstd::vector< float > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< float > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< float > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyFloat32Array((ccstd::string const &)*arg2,(ccstd::vector< float > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyFloat32Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyFloat32Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyFloat32Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyFloat32Array) + +static bool js_cc_Material_setPropertyInt32Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< int32_t > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< int32_t > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyInt32Array((ccstd::string const &)*arg2,(ccstd::vector< int32_t > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< int32_t > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< int32_t > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyInt32Array((ccstd::string const &)*arg2,(ccstd::vector< int32_t > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyInt32Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyInt32Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyInt32Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyInt32Array) + +static bool js_cc_Material_setPropertyVec2Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec2 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec2 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec2Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec2 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec2 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec2 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec2Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec2 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec2Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec2Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec2Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec2Array) + +static bool js_cc_Material_setPropertyVec3Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec3Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec3Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec3Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec3Array) + +static bool js_cc_Material_setPropertyVec4Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec4 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec4 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyVec4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec4 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Vec4 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Vec4 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyVec4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Vec4 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyVec4Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyVec4Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyVec4Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyVec4Array) + +static bool js_cc_Material_setPropertyColorArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Color > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Color > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyColorArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Color > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyColorArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Color > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Color > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyColorArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Color > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyColorArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyColorArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyColorArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyColorArray) + +static bool js_cc_Material_setPropertyMat3Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat3 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat3 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat3 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat3 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat3Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat3 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat3Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat3Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat3Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat3Array) + +static bool js_cc_Material_setPropertyMat4Array__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat4 > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat4 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyMat4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat4 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4Array__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Mat4 > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Mat4 > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyMat4Array((ccstd::string const &)*arg2,(ccstd::vector< cc::Mat4 > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyMat4Array(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyMat4Array__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyMat4Array__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyMat4Array) + +static bool js_cc_Material_setPropertyQuaternionArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Quaternion > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::Quaternion > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyQuaternionArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Quaternion > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternionArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::Quaternion > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::Quaternion > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyQuaternionArray((ccstd::string const &)*arg2,(ccstd::vector< cc::Quaternion > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyQuaternionArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyQuaternionArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyQuaternionArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyQuaternionArray) + +static bool js_cc_Material_setPropertyTextureBaseArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::TextureBase * > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::TextureBase * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyTextureBaseArray((ccstd::string const &)*arg2,(ccstd::vector< cc::TextureBase * > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBaseArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::TextureBase * > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::TextureBase * > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyTextureBaseArray((ccstd::string const &)*arg2,(ccstd::vector< cc::TextureBase * > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyTextureBaseArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyTextureBaseArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyTextureBaseArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyTextureBaseArray) + +static bool js_cc_Material_setPropertyGFXTextureArray__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::gfx::Texture * > *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + ccstd::vector< cc::gfx::Texture * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPropertyGFXTextureArray((ccstd::string const &)*arg2,(ccstd::vector< cc::gfx::Texture * > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTextureArray__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::vector< cc::gfx::Texture * > *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::vector< cc::gfx::Texture * > temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setPropertyGFXTextureArray((ccstd::string const &)*arg2,(ccstd::vector< cc::gfx::Texture * > const &)*arg3); + + + return true; +} + +static bool js_cc_Material_setPropertyGFXTextureArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Material_setPropertyGFXTextureArray__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Material_setPropertyGFXTextureArray__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_setPropertyGFXTextureArray) + +static bool js_cc_Material__getProperty__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + index_t arg3 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (cc::MaterialPropertyVariant *)((cc::Material const *)arg1)->getProperty((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; +} + +static bool js_cc_Material__getProperty__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::MaterialPropertyVariant *)((cc::Material const *)arg1)->getProperty((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; +} + +static bool js_cc_Material__getProperty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Material__getProperty__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Material__getProperty__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material__getProperty) + +static bool js_cc_Material_copy__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg3 = 0 ; + cc::IMaterialInfo temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->copy((cc::Material const *)arg2,(cc::IMaterialInfo const &)*arg3); + + + return true; +} + +static bool js_cc_Material_copy__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->copy((cc::Material const *)arg2); + + + return true; +} + +static bool js_cc_Material_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Material_copy__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Material_copy__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Material_copy) + +static bool js_cc_Material_fillInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::IMaterialInfo *arg2 = 0 ; + cc::IMaterialInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->fillInfo((cc::IMaterialInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Material_fillInfo) + +static bool js_cc_Material__effectAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_effectAsset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__effectAsset_set) + +static bool js_cc_Material__effectAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_effectAsset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_effectAsset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__effectAsset_get) + +static bool js_cc_Material__techIdx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_techIdx, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__techIdx_set) + +static bool js_cc_Material__techIdx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_techIdx, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__techIdx_get) + +static bool js_cc_Material__defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__defines_set) + +static bool js_cc_Material__defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__defines_get) + +static bool js_cc_Material__states_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_states, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__states_set) + +static bool js_cc_Material__states_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_states, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_states, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__states_get) + +static bool js_cc_Material__propsInternal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_props, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material__propsInternal_set) + +static bool js_cc_Material__propsInternal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_props, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_props, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material__propsInternal_get) + +static bool js_cc_Material_getPasses(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + std::shared_ptr< ccstd::vector< cc::IntrusivePtr< cc::scene::Pass > > > *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(s); + if (nullptr == arg1) return true; + result = (std::shared_ptr< ccstd::vector< cc::IntrusivePtr< cc::scene::Pass > > > *) &(arg1)->getPasses(); + + 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_Material_getPasses) + +static bool js_cc_Material_effectAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Material *arg1 = (cc::Material *) NULL ; + cc::EffectAsset *arg2 = (cc::EffectAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Material_effectAsset_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Material_effectAsset_set) + +static bool js_cc_Material_effectAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + cc::EffectAsset *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::EffectAsset *)cc_Material_effectAsset_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_Material_effectAsset_get) + +static bool js_cc_Material_effectName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::string result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Material_effectName_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_Material_effectName_get) + +static bool js_cc_Material_technique_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Material_technique_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Material_technique_get) + +static bool js_cc_Material_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Material_hash_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_Material_hash_get) + +static bool js_cc_Material_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Material *arg1 = (cc::Material *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_Material_parent_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_Material_parent_get) + +bool js_register_cc_Material(se::Object* obj) { + auto* cls = se::Class::create("Material", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_Material)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_effectAsset", _SE(js_cc_Material__effectAsset_get), _SE(js_cc_Material__effectAsset_set)); + cls->defineProperty("_techIdx", _SE(js_cc_Material__techIdx_get), _SE(js_cc_Material__techIdx_set)); + cls->defineProperty("_defines", _SE(js_cc_Material__defines_get), _SE(js_cc_Material__defines_set)); + cls->defineProperty("_states", _SE(js_cc_Material__states_get), _SE(js_cc_Material__states_set)); + cls->defineProperty("_propsInternal", _SE(js_cc_Material__propsInternal_get), _SE(js_cc_Material__propsInternal_set)); + cls->defineProperty("effectAsset", _SE(js_cc_Material_effectAsset_get), _SE(js_cc_Material_effectAsset_set)); + cls->defineProperty("effectName", _SE(js_cc_Material_effectName_get), nullptr); + cls->defineProperty("technique", _SE(js_cc_Material_technique_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_Material_hash_get), nullptr); + cls->defineProperty("parent", _SE(js_cc_Material_parent_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_Material_initialize)); + cls->defineFunction("reset", _SE(js_cc_Material_reset)); + cls->defineFunction("recompileShaders", _SE(js_cc_Material_recompileShaders)); + cls->defineFunction("overridePipelineStates", _SE(js_cc_Material_overridePipelineStates)); + cls->defineFunction("resetUniforms", _SE(js_cc_Material_resetUniforms)); + cls->defineFunction("setPropertyNull", _SE(js_cc_Material_setPropertyNull)); + cls->defineFunction("setPropertyFloat32", _SE(js_cc_Material_setPropertyFloat32)); + cls->defineFunction("setPropertyInt32", _SE(js_cc_Material_setPropertyInt32)); + cls->defineFunction("setPropertyVec2", _SE(js_cc_Material_setPropertyVec2)); + cls->defineFunction("setPropertyVec3", _SE(js_cc_Material_setPropertyVec3)); + cls->defineFunction("setPropertyVec4", _SE(js_cc_Material_setPropertyVec4)); + cls->defineFunction("setPropertyColor", _SE(js_cc_Material_setPropertyColor)); + cls->defineFunction("setPropertyMat3", _SE(js_cc_Material_setPropertyMat3)); + cls->defineFunction("setPropertyMat4", _SE(js_cc_Material_setPropertyMat4)); + cls->defineFunction("setPropertyQuaternion", _SE(js_cc_Material_setPropertyQuaternion)); + cls->defineFunction("setPropertyTextureBase", _SE(js_cc_Material_setPropertyTextureBase)); + cls->defineFunction("setPropertyGFXTexture", _SE(js_cc_Material_setPropertyGFXTexture)); + cls->defineFunction("setPropertyFloat32Array", _SE(js_cc_Material_setPropertyFloat32Array)); + cls->defineFunction("setPropertyInt32Array", _SE(js_cc_Material_setPropertyInt32Array)); + cls->defineFunction("setPropertyVec2Array", _SE(js_cc_Material_setPropertyVec2Array)); + cls->defineFunction("setPropertyVec3Array", _SE(js_cc_Material_setPropertyVec3Array)); + cls->defineFunction("setPropertyVec4Array", _SE(js_cc_Material_setPropertyVec4Array)); + cls->defineFunction("setPropertyColorArray", _SE(js_cc_Material_setPropertyColorArray)); + cls->defineFunction("setPropertyMat3Array", _SE(js_cc_Material_setPropertyMat3Array)); + cls->defineFunction("setPropertyMat4Array", _SE(js_cc_Material_setPropertyMat4Array)); + cls->defineFunction("setPropertyQuaternionArray", _SE(js_cc_Material_setPropertyQuaternionArray)); + cls->defineFunction("setPropertyTextureBaseArray", _SE(js_cc_Material_setPropertyTextureBaseArray)); + cls->defineFunction("setPropertyGFXTextureArray", _SE(js_cc_Material_setPropertyGFXTextureArray)); + cls->defineFunction("_getProperty", _SE(js_cc_Material__getProperty)); + cls->defineFunction("copy", _SE(js_cc_Material_copy)); + cls->defineFunction("fillInfo", _SE(js_cc_Material_fillInfo)); + cls->defineFunction("getPasses", _SE(js_cc_Material_getPasses)); + + + cls->defineStaticFunction("getHash", _SE(js_cc_Material_getHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Material)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Material_proto = cls->getProto(); + __jsb_cc_Material_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IGeometricInfo_class = nullptr; +se::Object* __jsb_cc_IGeometricInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IGeometricInfo) + +static bool js_cc_IGeometricInfo_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_positions_set) + +static bool js_cc_IGeometricInfo_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_positions_get) + +static bool js_cc_IGeometricInfo_indices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_indices_set) + +static bool js_cc_IGeometricInfo_indices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_indices_get) + +static bool js_cc_IGeometricInfo_doubleSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->doubleSided, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_doubleSided_set) + +static bool js_cc_IGeometricInfo_doubleSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->doubleSided, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->doubleSided, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_doubleSided_get) + +static bool js_cc_IGeometricInfo_boundingBox_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->boundingBox, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IGeometricInfo_boundingBox_set) + +static bool js_cc_IGeometricInfo_boundingBox_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IGeometricInfo *arg1 = (cc::IGeometricInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->boundingBox, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->boundingBox, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IGeometricInfo_boundingBox_get) + +static bool js_new_cc_IGeometricInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IGeometricInfo *result; + result = (cc::IGeometricInfo *)new cc::IGeometricInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IGeometricInfo, __jsb_cc_IGeometricInfo_class, js_delete_cc_IGeometricInfo) + +static bool js_delete_cc_IGeometricInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IGeometricInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometricInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("indices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indices), ctx); + } + + + json->getProperty("doubleSided", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->doubleSided), ctx); + } + + + json->getProperty("boundingBox", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->boundingBox), ctx); + } + + + return ok; +} + + +bool js_register_cc_IGeometricInfo(se::Object* obj) { + auto* cls = se::Class::create("IGeometricInfo", obj, nullptr, _SE(js_new_cc_IGeometricInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("positions", _SE(js_cc_IGeometricInfo_positions_get), _SE(js_cc_IGeometricInfo_positions_set)); + cls->defineProperty("indices", _SE(js_cc_IGeometricInfo_indices_get), _SE(js_cc_IGeometricInfo_indices_set)); + cls->defineProperty("doubleSided", _SE(js_cc_IGeometricInfo_doubleSided_get), _SE(js_cc_IGeometricInfo_doubleSided_set)); + cls->defineProperty("boundingBox", _SE(js_cc_IGeometricInfo_boundingBox_get), _SE(js_cc_IGeometricInfo_boundingBox_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IGeometricInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IGeometricInfo_proto = cls->getProto(); + __jsb_cc_IGeometricInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IFlatBuffer_class = nullptr; +se::Object* __jsb_cc_IFlatBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IFlatBuffer) + +static bool js_cc_IFlatBuffer_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IFlatBuffer_stride_set) + +static bool js_cc_IFlatBuffer_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IFlatBuffer_stride_get) + +static bool js_cc_IFlatBuffer_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IFlatBuffer_count_set) + +static bool js_cc_IFlatBuffer_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IFlatBuffer_count_get) + +static bool js_cc_IFlatBuffer_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IFlatBuffer_buffer_set) + +static bool js_cc_IFlatBuffer_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IFlatBuffer *arg1 = (cc::IFlatBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IFlatBuffer_buffer_get) + +static bool js_new_cc_IFlatBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IFlatBuffer *result; + result = (cc::IFlatBuffer *)new cc::IFlatBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IFlatBuffer, __jsb_cc_IFlatBuffer_class, js_delete_cc_IFlatBuffer) + +static bool js_delete_cc_IFlatBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IFlatBuffer) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IFlatBuffer * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + return ok; +} + + +bool js_register_cc_IFlatBuffer(se::Object* obj) { + auto* cls = se::Class::create("IFlatBuffer", obj, nullptr, _SE(js_new_cc_IFlatBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("stride", _SE(js_cc_IFlatBuffer_stride_get), _SE(js_cc_IFlatBuffer_stride_set)); + cls->defineProperty("count", _SE(js_cc_IFlatBuffer_count_get), _SE(js_cc_IFlatBuffer_count_set)); + cls->defineProperty("buffer", _SE(js_cc_IFlatBuffer_buffer_get), _SE(js_cc_IFlatBuffer_buffer_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IFlatBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IFlatBuffer_proto = cls->getProto(); + __jsb_cc_IFlatBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_RenderingSubMesh_class = nullptr; +se::Object* __jsb_cc_RenderingSubMesh_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_RenderingSubMesh) + +static bool js_new_cc_RenderingSubMesh__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::Buffer *arg4 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::Buffer *arg4 = (cc::gfx::Buffer *) NULL ; + cc::gfx::Buffer *arg5 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gfx::BufferList *arg1 = 0 ; + cc::gfx::AttributeList *arg2 = 0 ; + cc::gfx::PrimitiveMode arg3 ; + cc::gfx::Buffer *arg4 = (cc::gfx::Buffer *) NULL ; + cc::gfx::Buffer *arg5 = (cc::gfx::Buffer *) NULL ; + bool arg6 ; + cc::gfx::BufferList temp1 ; + cc::gfx::AttributeList temp2 ; + cc::RenderingSubMesh *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::RenderingSubMesh *)new cc::RenderingSubMesh((cc::gfx::BufferList const &)*arg1,(cc::gfx::AttributeList const &)*arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_RenderingSubMesh(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_cc_RenderingSubMesh__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_RenderingSubMesh__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_RenderingSubMesh__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 6) { + ret = js_new_cc_RenderingSubMesh__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of RenderingSubMesh"); + return false; +} +SE_BIND_CTOR(js_new_cc_RenderingSubMesh, __jsb_cc_RenderingSubMesh_class, js_delete_cc_RenderingSubMesh) + +static bool js_delete_cc_RenderingSubMesh(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_RenderingSubMesh) + +static bool js_cc_RenderingSubMesh_getAttributes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::AttributeList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::AttributeList *) &((cc::RenderingSubMesh const *)arg1)->getAttributes(); + + 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_RenderingSubMesh_getAttributes) + +static bool js_cc_RenderingSubMesh_getVertexBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::BufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &((cc::RenderingSubMesh const *)arg1)->getVertexBuffers(); + + 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_RenderingSubMesh_getVertexBuffers) + +static bool js_cc_RenderingSubMesh_getIndexBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::RenderingSubMesh const *)arg1)->getIndexBuffer(); + + 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_RenderingSubMesh_getIndexBuffer) + +static bool js_cc_RenderingSubMesh_indirectBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::RenderingSubMesh const *)arg1)->indirectBuffer(); + + 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_RenderingSubMesh_indirectBuffer) + +static bool js_cc_RenderingSubMesh_getGeometricInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::IGeometricInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::IGeometricInfo *) &(arg1)->getGeometricInfo(); + + 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_RenderingSubMesh_getGeometricInfo) + +static bool js_cc_RenderingSubMesh_invalidateGeometricInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidateGeometricInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_invalidateGeometricInfo) + +static bool js_cc_RenderingSubMesh_genFlatBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->genFlatBuffers(); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_genFlatBuffers) + +static bool js_cc_RenderingSubMesh_setDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::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(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)->setDrawInfo((cc::gfx::DrawInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_setDrawInfo) + +static bool js_cc_RenderingSubMesh_getDrawInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::optional< cc::gfx::DrawInfo > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< cc::gfx::DrawInfo > *) &(arg1)->getDrawInfo(); + + 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_RenderingSubMesh_getDrawInfo) + +static bool js_cc_RenderingSubMesh_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) 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(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_RenderingSubMesh_destroy) + +static bool js_cc_RenderingSubMesh_enableVertexIdChannel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableVertexIdChannel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_RenderingSubMesh_enableVertexIdChannel) + +static bool js_cc_RenderingSubMesh_mesh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_RenderingSubMesh_mesh_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh_mesh_set) + +static bool js_cc_RenderingSubMesh_mesh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::Mesh *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mesh *)cc_RenderingSubMesh_mesh_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_RenderingSubMesh_mesh_get) + +static bool js_cc_RenderingSubMesh_subMeshIdx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::optional< uint32_t > *arg2 = 0 ; + ccstd::optional< uint32_t > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_RenderingSubMesh_subMeshIdx_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh_subMeshIdx_set) + +static bool js_cc_RenderingSubMesh_subMeshIdx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::optional< uint32_t > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< uint32_t > *) &cc_RenderingSubMesh_subMeshIdx_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_RenderingSubMesh_subMeshIdx_get) + +static bool js_cc_RenderingSubMesh_flatBuffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *arg2 = 0 ; + ccstd::vector< cc::IFlatBuffer > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_RenderingSubMesh_flatBuffers_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh_flatBuffers_set) + +static bool js_cc_RenderingSubMesh_flatBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IFlatBuffer > *) &cc_RenderingSubMesh_flatBuffers_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_RenderingSubMesh_flatBuffers_get) + +static bool js_cc_RenderingSubMesh__flatBuffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *arg2 = 0 ; + ccstd::vector< cc::IFlatBuffer > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_RenderingSubMesh__flatBuffers_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_RenderingSubMesh__flatBuffers_set) + +static bool js_cc_RenderingSubMesh__flatBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + ccstd::vector< cc::IFlatBuffer > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IFlatBuffer > *) &cc_RenderingSubMesh__flatBuffers_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_RenderingSubMesh__flatBuffers_get) + +static bool js_cc_RenderingSubMesh_jointMappedBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::BufferList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &cc_RenderingSubMesh_jointMappedBuffers_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_RenderingSubMesh_jointMappedBuffers_get) + +static bool js_cc_RenderingSubMesh_iaInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::InputAssemblerInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssemblerInfo *) &cc_RenderingSubMesh_iaInfo_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_RenderingSubMesh_iaInfo_get) + +static bool js_cc_RenderingSubMesh__iaInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::InputAssemblerInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssemblerInfo *) &cc_RenderingSubMesh__iaInfo_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_RenderingSubMesh__iaInfo_get) + +static bool js_cc_RenderingSubMesh_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::RenderingSubMesh *arg1 = (cc::RenderingSubMesh *) NULL ; + cc::gfx::PrimitiveMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PrimitiveMode)cc_RenderingSubMesh_primitiveMode_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_RenderingSubMesh_primitiveMode_get) + +bool js_register_cc_RenderingSubMesh(se::Object* obj) { + auto* cls = se::Class::create("RenderingSubMesh", obj, nullptr, _SE(js_new_cc_RenderingSubMesh)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mesh", _SE(js_cc_RenderingSubMesh_mesh_get), _SE(js_cc_RenderingSubMesh_mesh_set)); + cls->defineProperty("subMeshIdx", _SE(js_cc_RenderingSubMesh_subMeshIdx_get), _SE(js_cc_RenderingSubMesh_subMeshIdx_set)); + cls->defineProperty("flatBuffers", _SE(js_cc_RenderingSubMesh_flatBuffers_get), _SE(js_cc_RenderingSubMesh_flatBuffers_set)); + cls->defineProperty("_flatBuffers", _SE(js_cc_RenderingSubMesh__flatBuffers_get), _SE(js_cc_RenderingSubMesh__flatBuffers_set)); + cls->defineProperty("jointMappedBuffers", _SE(js_cc_RenderingSubMesh_jointMappedBuffers_get), nullptr); + cls->defineProperty("iaInfo", _SE(js_cc_RenderingSubMesh_iaInfo_get), nullptr); + cls->defineProperty("_iaInfo", _SE(js_cc_RenderingSubMesh__iaInfo_get), nullptr); + cls->defineProperty("primitiveMode", _SE(js_cc_RenderingSubMesh_primitiveMode_get), nullptr); + + cls->defineFunction("getAttributes", _SE(js_cc_RenderingSubMesh_getAttributes)); + cls->defineFunction("getVertexBuffers", _SE(js_cc_RenderingSubMesh_getVertexBuffers)); + cls->defineFunction("getIndexBuffer", _SE(js_cc_RenderingSubMesh_getIndexBuffer)); + cls->defineFunction("indirectBuffer", _SE(js_cc_RenderingSubMesh_indirectBuffer)); + cls->defineFunction("getGeometricInfo", _SE(js_cc_RenderingSubMesh_getGeometricInfo)); + cls->defineFunction("invalidateGeometricInfo", _SE(js_cc_RenderingSubMesh_invalidateGeometricInfo)); + cls->defineFunction("genFlatBuffers", _SE(js_cc_RenderingSubMesh_genFlatBuffers)); + cls->defineFunction("setDrawInfo", _SE(js_cc_RenderingSubMesh_setDrawInfo)); + cls->defineFunction("getDrawInfo", _SE(js_cc_RenderingSubMesh_getDrawInfo)); + cls->defineFunction("destroy", _SE(js_cc_RenderingSubMesh_destroy)); + cls->defineFunction("enableVertexIdChannel", _SE(js_cc_RenderingSubMesh_enableVertexIdChannel)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_RenderingSubMesh)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_RenderingSubMesh_proto = cls->getProto(); + __jsb_cc_RenderingSubMesh_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BuiltinResMgr_class = nullptr; +se::Object* __jsb_cc_BuiltinResMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BuiltinResMgr) + +static bool js_cc_BuiltinResMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::BuiltinResMgr *)cc::BuiltinResMgr::getInstance(); + + 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_BuiltinResMgr_getInstance_static) + +static bool js_new_cc_BuiltinResMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BuiltinResMgr *result; + result = (cc::BuiltinResMgr *)new cc::BuiltinResMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BuiltinResMgr, __jsb_cc_BuiltinResMgr_class, js_delete_cc_BuiltinResMgr) + +static bool js_delete_cc_BuiltinResMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BuiltinResMgr) + +static bool js_cc_BuiltinResMgr_initBuiltinRes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->initBuiltinRes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_BuiltinResMgr_initBuiltinRes) + +static bool js_cc_BuiltinResMgr_isInitialized(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::BuiltinResMgr const *)arg1)->isInitialized(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_BuiltinResMgr_isInitialized) + +static bool js_cc_BuiltinResMgr_addAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Asset *arg3 = (cc::Asset *) 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(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)->addAsset((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_BuiltinResMgr_addAsset) + +static bool js_cc_BuiltinResMgr_getAsset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BuiltinResMgr *arg1 = (cc::BuiltinResMgr *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Asset *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(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::Asset *)(arg1)->getAsset((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_BuiltinResMgr_getAsset) + +bool js_register_cc_BuiltinResMgr(se::Object* obj) { + auto* cls = se::Class::create("BuiltinResMgr", obj, nullptr, _SE(js_new_cc_BuiltinResMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initBuiltinRes", _SE(js_cc_BuiltinResMgr_initBuiltinRes)); + cls->defineFunction("isInitialized", _SE(js_cc_BuiltinResMgr_isInitialized)); + cls->defineFunction("addAsset", _SE(js_cc_BuiltinResMgr_addAsset)); + cls->defineFunction("getAsset", _SE(js_cc_BuiltinResMgr_getAsset)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_BuiltinResMgr_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BuiltinResMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BuiltinResMgr_proto = cls->getProto(); + __jsb_cc_BuiltinResMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMeshBufferView_class = nullptr; +se::Object* __jsb_cc_IMeshBufferView_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMeshBufferView) + +static bool js_cc_IMeshBufferView_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_offset_set) + +static bool js_cc_IMeshBufferView_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_offset_get) + +static bool js_cc_IMeshBufferView_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->length, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_length_set) + +static bool js_cc_IMeshBufferView_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->length, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_length_get) + +static bool js_cc_IMeshBufferView_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_count_set) + +static bool js_cc_IMeshBufferView_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_count_get) + +static bool js_cc_IMeshBufferView_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMeshBufferView_stride_set) + +static bool js_cc_IMeshBufferView_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMeshBufferView *arg1 = (cc::IMeshBufferView *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMeshBufferView_stride_get) + +static bool js_new_cc_IMeshBufferView(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMeshBufferView *result; + result = (cc::IMeshBufferView *)new cc::IMeshBufferView(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMeshBufferView, __jsb_cc_IMeshBufferView_class, js_delete_cc_IMeshBufferView) + +static bool js_delete_cc_IMeshBufferView(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMeshBufferView) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMeshBufferView * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("length", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->length), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMeshBufferView(se::Object* obj) { + auto* cls = se::Class::create("IMeshBufferView", obj, nullptr, _SE(js_new_cc_IMeshBufferView)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("offset", _SE(js_cc_IMeshBufferView_offset_get), _SE(js_cc_IMeshBufferView_offset_set)); + cls->defineProperty("length", _SE(js_cc_IMeshBufferView_length_get), _SE(js_cc_IMeshBufferView_length_set)); + cls->defineProperty("count", _SE(js_cc_IMeshBufferView_count_get), _SE(js_cc_IMeshBufferView_count_set)); + cls->defineProperty("stride", _SE(js_cc_IMeshBufferView_stride_get), _SE(js_cc_IMeshBufferView_stride_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMeshBufferView)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMeshBufferView_proto = cls->getProto(); + __jsb_cc_IMeshBufferView_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphTarget_class = nullptr; +se::Object* __jsb_cc_MorphTarget_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphTarget) + +static bool js_cc_MorphTarget_displacements_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphTarget *arg1 = (cc::MorphTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displacements, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_MorphTarget_displacements_set) + +static bool js_cc_MorphTarget_displacements_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::MorphTarget *arg1 = (cc::MorphTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displacements, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->displacements, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_MorphTarget_displacements_get) + +static bool js_new_cc_MorphTarget(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MorphTarget *result; + result = (cc::MorphTarget *)new cc::MorphTarget(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MorphTarget, __jsb_cc_MorphTarget_class, js_delete_cc_MorphTarget) + +static bool js_delete_cc_MorphTarget(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphTarget) + +template<> +bool sevalue_to_native(const se::Value &from, cc::MorphTarget * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("displacements", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->displacements), ctx); + } + + + return ok; +} + + +bool js_register_cc_MorphTarget(se::Object* obj) { + auto* cls = se::Class::create("MorphTarget", obj, nullptr, _SE(js_new_cc_MorphTarget)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("displacements", _SE(js_cc_MorphTarget_displacements_get), _SE(js_cc_MorphTarget_displacements_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphTarget)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphTarget_proto = cls->getProto(); + __jsb_cc_MorphTarget_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SubMeshMorph_class = nullptr; +se::Object* __jsb_cc_SubMeshMorph_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SubMeshMorph) + +static bool js_cc_SubMeshMorph_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_SubMeshMorph_attributes_set) + +static bool js_cc_SubMeshMorph_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_SubMeshMorph_attributes_get) + +static bool js_cc_SubMeshMorph_targets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_SubMeshMorph_targets_set) + +static bool js_cc_SubMeshMorph_targets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targets, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targets, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_SubMeshMorph_targets_get) + +static bool js_cc_SubMeshMorph_weights_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->weights, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_SubMeshMorph_weights_set) + +static bool js_cc_SubMeshMorph_weights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SubMeshMorph *arg1 = (cc::SubMeshMorph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->weights, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->weights, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_SubMeshMorph_weights_get) + +static bool js_new_cc_SubMeshMorph(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SubMeshMorph *result; + result = (cc::SubMeshMorph *)new cc::SubMeshMorph(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SubMeshMorph, __jsb_cc_SubMeshMorph_class, js_delete_cc_SubMeshMorph) + +static bool js_delete_cc_SubMeshMorph(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SubMeshMorph) + +template<> +bool sevalue_to_native(const se::Value &from, cc::SubMeshMorph * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("targets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targets), ctx); + } + + + json->getProperty("weights", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->weights), ctx); + } + + + return ok; +} + + +bool js_register_cc_SubMeshMorph(se::Object* obj) { + auto* cls = se::Class::create("SubMeshMorph", obj, nullptr, _SE(js_new_cc_SubMeshMorph)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attributes", _SE(js_cc_SubMeshMorph_attributes_get), _SE(js_cc_SubMeshMorph_attributes_set)); + cls->defineProperty("targets", _SE(js_cc_SubMeshMorph_targets_get), _SE(js_cc_SubMeshMorph_targets_set)); + cls->defineProperty("weights", _SE(js_cc_SubMeshMorph_weights_get), _SE(js_cc_SubMeshMorph_weights_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SubMeshMorph)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SubMeshMorph_proto = cls->getProto(); + __jsb_cc_SubMeshMorph_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Morph_class = nullptr; +se::Object* __jsb_cc_Morph_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Morph) + +static bool js_cc_Morph_subMeshMorphs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subMeshMorphs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Morph_subMeshMorphs_set) + +static bool js_cc_Morph_subMeshMorphs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subMeshMorphs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subMeshMorphs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Morph_subMeshMorphs_get) + +static bool js_cc_Morph_weights_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->weights, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Morph_weights_set) + +static bool js_cc_Morph_weights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->weights, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->weights, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Morph_weights_get) + +static bool js_cc_Morph_targetNames_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targetNames, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Morph_targetNames_set) + +static bool js_cc_Morph_targetNames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Morph *arg1 = (cc::Morph *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targetNames, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targetNames, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Morph_targetNames_get) + +static bool js_new_cc_Morph(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Morph *result; + result = (cc::Morph *)new cc::Morph(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Morph, __jsb_cc_Morph_class, js_delete_cc_Morph) + +static bool js_delete_cc_Morph(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Morph) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Morph * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("subMeshMorphs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subMeshMorphs), ctx); + } + + + json->getProperty("weights", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->weights), ctx); + } + + + json->getProperty("targetNames", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targetNames), ctx); + } + + + return ok; +} + + +bool js_register_cc_Morph(se::Object* obj) { + auto* cls = se::Class::create("Morph", obj, nullptr, _SE(js_new_cc_Morph)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("subMeshMorphs", _SE(js_cc_Morph_subMeshMorphs_get), _SE(js_cc_Morph_subMeshMorphs_set)); + cls->defineProperty("weights", _SE(js_cc_Morph_weights_get), _SE(js_cc_Morph_weights_set)); + cls->defineProperty("targetNames", _SE(js_cc_Morph_targetNames_get), _SE(js_cc_Morph_targetNames_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Morph)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Morph_proto = cls->getProto(); + __jsb_cc_Morph_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphRenderingInstance_class = nullptr; +se::Object* __jsb_cc_MorphRenderingInstance_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphRenderingInstance) + +static bool js_delete_cc_MorphRenderingInstance(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphRenderingInstance) + +static bool js_cc_MorphRenderingInstance_setWeights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + index_t arg2 ; + cc::MeshWeightsType *arg3 = 0 ; + cc::MeshWeightsType temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setWeights(arg2,(cc::MeshWeightsType const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_setWeights) + +static bool js_cc_MorphRenderingInstance_adaptPipelineState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->adaptPipelineState(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_adaptPipelineState) + +static bool js_cc_MorphRenderingInstance_requiredPatches(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + index_t arg2 ; + ccstd::vector< cc::scene::IMacroPatch > result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->requiredPatches(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_requiredPatches) + +static bool js_cc_MorphRenderingInstance_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRenderingInstance *arg1 = (cc::MorphRenderingInstance *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphRenderingInstance_destroy) + +bool js_register_cc_MorphRenderingInstance(se::Object* obj) { + auto* cls = se::Class::create("MorphRenderingInstance", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setWeights", _SE(js_cc_MorphRenderingInstance_setWeights)); + cls->defineFunction("adaptPipelineState", _SE(js_cc_MorphRenderingInstance_adaptPipelineState)); + cls->defineFunction("requiredPatches", _SE(js_cc_MorphRenderingInstance_requiredPatches)); + cls->defineFunction("destroy", _SE(js_cc_MorphRenderingInstance_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphRenderingInstance)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphRenderingInstance_proto = cls->getProto(); + __jsb_cc_MorphRenderingInstance_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphRendering_class = nullptr; +se::Object* __jsb_cc_MorphRendering_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphRendering) + +static bool js_delete_cc_MorphRendering(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphRendering) + +static bool js_cc_MorphRendering_createInstance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphRendering *arg1 = (cc::MorphRendering *) NULL ; + cc::MorphRenderingInstance *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(s); + if (nullptr == arg1) return true; + result = (cc::MorphRenderingInstance *)(arg1)->createInstance(); + + 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_MorphRendering_createInstance) + +bool js_register_cc_MorphRendering(se::Object* obj) { + auto* cls = se::Class::create("MorphRendering", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("createInstance", _SE(js_cc_MorphRendering_createInstance)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphRendering)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphRendering_proto = cls->getProto(); + __jsb_cc_MorphRendering_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_StdMorphRendering_class = nullptr; +se::Object* __jsb_cc_StdMorphRendering_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_StdMorphRendering) + +static bool js_new_cc_StdMorphRendering(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::StdMorphRendering *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::StdMorphRendering *)new cc::StdMorphRendering(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_StdMorphRendering, __jsb_cc_StdMorphRendering_class, js_delete_cc_StdMorphRendering) + +static bool js_delete_cc_StdMorphRendering(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_StdMorphRendering) + +bool js_register_cc_StdMorphRendering(se::Object* obj) { + auto* cls = se::Class::create("StdMorphRendering", obj, __jsb_cc_MorphRendering_proto, _SE(js_new_cc_StdMorphRendering)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_StdMorphRendering)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_StdMorphRendering_proto = cls->getProto(); + __jsb_cc_StdMorphRendering_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_createMorphRendering(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::MorphRendering *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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::MorphRendering *)cc::createMorphRendering(arg1,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_createMorphRendering) + +se::Class* __jsb_cc_Mesh_class = nullptr; +se::Object* __jsb_cc_Mesh_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh) + +se::Class* __jsb_cc_Mesh_IVertexBundle_class = nullptr; +se::Object* __jsb_cc_Mesh_IVertexBundle_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IVertexBundle) + +static bool js_cc_Mesh_IVertexBundle__padding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_padding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IVertexBundle__padding_set) + +static bool js_cc_Mesh_IVertexBundle__padding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_padding, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_padding, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IVertexBundle__padding_get) + +static bool js_cc_Mesh_IVertexBundle_view_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->view, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IVertexBundle_view_set) + +static bool js_cc_Mesh_IVertexBundle_view_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->view, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->view, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IVertexBundle_view_get) + +static bool js_cc_Mesh_IVertexBundle_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IVertexBundle_attributes_set) + +static bool js_cc_Mesh_IVertexBundle_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IVertexBundle *arg1 = (cc::Mesh::IVertexBundle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IVertexBundle_attributes_get) + +static bool js_new_cc_Mesh_IVertexBundle(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IVertexBundle *result; + result = (cc::Mesh::IVertexBundle *)new cc::Mesh::IVertexBundle(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IVertexBundle, __jsb_cc_Mesh_IVertexBundle_class, js_delete_cc_Mesh_IVertexBundle) + +static bool js_delete_cc_Mesh_IVertexBundle(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IVertexBundle) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IVertexBundle * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("_padding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_padding), ctx); + } + + + json->getProperty("view", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->view), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IVertexBundle(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IVertexBundle"}, obj, nullptr, _SE(js_new_cc_Mesh_IVertexBundle)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_padding", _SE(js_cc_Mesh_IVertexBundle__padding_get), _SE(js_cc_Mesh_IVertexBundle__padding_set)); + cls->defineProperty("view", _SE(js_cc_Mesh_IVertexBundle_view_get), _SE(js_cc_Mesh_IVertexBundle_view_set)); + cls->defineProperty("attributes", _SE(js_cc_Mesh_IVertexBundle_attributes_get), _SE(js_cc_Mesh_IVertexBundle_attributes_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IVertexBundle)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IVertexBundle_proto = cls->getProto(); + __jsb_cc_Mesh_IVertexBundle_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IMeshCluster_class = nullptr; +se::Object* __jsb_cc_Mesh_IMeshCluster_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IMeshCluster) + +static bool js_cc_Mesh_IMeshCluster_clusterView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->clusterView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_clusterView_set) + +static bool js_cc_Mesh_IMeshCluster_clusterView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->clusterView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->clusterView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_clusterView_get) + +static bool js_cc_Mesh_IMeshCluster_triangleView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->triangleView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_triangleView_set) + +static bool js_cc_Mesh_IMeshCluster_triangleView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->triangleView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->triangleView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_triangleView_get) + +static bool js_cc_Mesh_IMeshCluster_vertexView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_vertexView_set) + +static bool js_cc_Mesh_IMeshCluster_vertexView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_vertexView_get) + +static bool js_cc_Mesh_IMeshCluster_coneView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->coneView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IMeshCluster_coneView_set) + +static bool js_cc_Mesh_IMeshCluster_coneView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IMeshCluster *arg1 = (cc::Mesh::IMeshCluster *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->coneView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->coneView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IMeshCluster_coneView_get) + +static bool js_new_cc_Mesh_IMeshCluster(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IMeshCluster *result; + result = (cc::Mesh::IMeshCluster *)new cc::Mesh::IMeshCluster(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IMeshCluster, __jsb_cc_Mesh_IMeshCluster_class, js_delete_cc_Mesh_IMeshCluster) + +static bool js_delete_cc_Mesh_IMeshCluster(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IMeshCluster) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IMeshCluster * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("clusterView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->clusterView), ctx); + } + + + json->getProperty("triangleView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->triangleView), ctx); + } + + + json->getProperty("vertexView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexView), ctx); + } + + + json->getProperty("coneView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->coneView), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IMeshCluster(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IMeshCluster"}, obj, nullptr, _SE(js_new_cc_Mesh_IMeshCluster)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("clusterView", _SE(js_cc_Mesh_IMeshCluster_clusterView_get), _SE(js_cc_Mesh_IMeshCluster_clusterView_set)); + cls->defineProperty("triangleView", _SE(js_cc_Mesh_IMeshCluster_triangleView_get), _SE(js_cc_Mesh_IMeshCluster_triangleView_set)); + cls->defineProperty("vertexView", _SE(js_cc_Mesh_IMeshCluster_vertexView_get), _SE(js_cc_Mesh_IMeshCluster_vertexView_set)); + cls->defineProperty("coneView", _SE(js_cc_Mesh_IMeshCluster_coneView_get), _SE(js_cc_Mesh_IMeshCluster_coneView_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IMeshCluster)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IMeshCluster_proto = cls->getProto(); + __jsb_cc_Mesh_IMeshCluster_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_ISubMesh_class = nullptr; +se::Object* __jsb_cc_Mesh_ISubMesh_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_ISubMesh) + +static bool js_cc_Mesh_ISubMesh_vertexBundelIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexBundelIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_vertexBundelIndices_set) + +static bool js_cc_Mesh_ISubMesh_vertexBundelIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexBundelIndices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexBundelIndices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_vertexBundelIndices_get) + +static bool js_cc_Mesh_ISubMesh_primitiveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitiveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_primitiveMode_set) + +static bool js_cc_Mesh_ISubMesh_primitiveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitiveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitiveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_primitiveMode_get) + +static bool js_cc_Mesh_ISubMesh_indexView_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexView, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_indexView_set) + +static bool js_cc_Mesh_ISubMesh_indexView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexView, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexView, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_indexView_get) + +static bool js_cc_Mesh_ISubMesh_jointMapIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->jointMapIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_jointMapIndex_set) + +static bool js_cc_Mesh_ISubMesh_jointMapIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->jointMapIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->jointMapIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_jointMapIndex_get) + +static bool js_cc_Mesh_ISubMesh_cluster_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cluster, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ISubMesh_cluster_set) + +static bool js_cc_Mesh_ISubMesh_cluster_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ISubMesh *arg1 = (cc::Mesh::ISubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cluster, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cluster, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ISubMesh_cluster_get) + +static bool js_new_cc_Mesh_ISubMesh(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::ISubMesh *result; + result = (cc::Mesh::ISubMesh *)new cc::Mesh::ISubMesh(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_ISubMesh, __jsb_cc_Mesh_ISubMesh_class, js_delete_cc_Mesh_ISubMesh) + +static bool js_delete_cc_Mesh_ISubMesh(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_ISubMesh) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ISubMesh * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vertexBundelIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexBundelIndices), ctx); + } + + + json->getProperty("primitiveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitiveMode), ctx); + } + + + json->getProperty("indexView", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexView), ctx); + } + + + json->getProperty("jointMapIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->jointMapIndex), ctx); + } + + + json->getProperty("cluster", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cluster), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_ISubMesh(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "ISubMesh"}, obj, nullptr, _SE(js_new_cc_Mesh_ISubMesh)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexBundelIndices", _SE(js_cc_Mesh_ISubMesh_vertexBundelIndices_get), _SE(js_cc_Mesh_ISubMesh_vertexBundelIndices_set)); + cls->defineProperty("primitiveMode", _SE(js_cc_Mesh_ISubMesh_primitiveMode_get), _SE(js_cc_Mesh_ISubMesh_primitiveMode_set)); + cls->defineProperty("indexView", _SE(js_cc_Mesh_ISubMesh_indexView_get), _SE(js_cc_Mesh_ISubMesh_indexView_set)); + cls->defineProperty("jointMapIndex", _SE(js_cc_Mesh_ISubMesh_jointMapIndex_get), _SE(js_cc_Mesh_ISubMesh_jointMapIndex_set)); + cls->defineProperty("cluster", _SE(js_cc_Mesh_ISubMesh_cluster_get), _SE(js_cc_Mesh_ISubMesh_cluster_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_ISubMesh)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_ISubMesh_proto = cls->getProto(); + __jsb_cc_Mesh_ISubMesh_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IDynamicInfo_class = nullptr; +se::Object* __jsb_cc_Mesh_IDynamicInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicInfo) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicInfo_maxSubMeshes_set) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicInfo_maxSubMeshes_get) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshVertices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_set) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshVertices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_get) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_set) + +static bool js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicInfo *arg1 = (cc::Mesh::IDynamicInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshIndices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_get) + +static bool js_new_cc_Mesh_IDynamicInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IDynamicInfo *result; + result = (cc::Mesh::IDynamicInfo *)new cc::Mesh::IDynamicInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IDynamicInfo, __jsb_cc_Mesh_IDynamicInfo_class, js_delete_cc_Mesh_IDynamicInfo) + +static bool js_delete_cc_Mesh_IDynamicInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxSubMeshes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshes), ctx); + } + + + json->getProperty("maxSubMeshVertices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshVertices), ctx); + } + + + json->getProperty("maxSubMeshIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshIndices), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IDynamicInfo(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IDynamicInfo"}, obj, nullptr, _SE(js_new_cc_Mesh_IDynamicInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxSubMeshes", _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshes_get), _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshes_set)); + cls->defineProperty("maxSubMeshVertices", _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_get), _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshVertices_set)); + cls->defineProperty("maxSubMeshIndices", _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_get), _SE(js_cc_Mesh_IDynamicInfo_maxSubMeshIndices_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IDynamicInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IDynamicInfo_proto = cls->getProto(); + __jsb_cc_Mesh_IDynamicInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IDynamicStruct_class = nullptr; +se::Object* __jsb_cc_Mesh_IDynamicStruct_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicStruct) + +static bool js_cc_Mesh_IDynamicStruct_info_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->info, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicStruct_info_set) + +static bool js_cc_Mesh_IDynamicStruct_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->info, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->info, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicStruct_info_get) + +static bool js_cc_Mesh_IDynamicStruct_bounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IDynamicStruct_bounds_set) + +static bool js_cc_Mesh_IDynamicStruct_bounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IDynamicStruct *arg1 = (cc::Mesh::IDynamicStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bounds, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bounds, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IDynamicStruct_bounds_get) + +static bool js_new_cc_Mesh_IDynamicStruct(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IDynamicStruct *result; + result = (cc::Mesh::IDynamicStruct *)new cc::Mesh::IDynamicStruct(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IDynamicStruct, __jsb_cc_Mesh_IDynamicStruct_class, js_delete_cc_Mesh_IDynamicStruct) + +static bool js_delete_cc_Mesh_IDynamicStruct(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IDynamicStruct) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicStruct * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("info", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->info), ctx); + } + + + json->getProperty("bounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bounds), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IDynamicStruct(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IDynamicStruct"}, obj, nullptr, _SE(js_new_cc_Mesh_IDynamicStruct)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("info", _SE(js_cc_Mesh_IDynamicStruct_info_get), _SE(js_cc_Mesh_IDynamicStruct_info_set)); + cls->defineProperty("bounds", _SE(js_cc_Mesh_IDynamicStruct_bounds_get), _SE(js_cc_Mesh_IDynamicStruct_bounds_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IDynamicStruct)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IDynamicStruct_proto = cls->getProto(); + __jsb_cc_Mesh_IDynamicStruct_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_IStruct_class = nullptr; +se::Object* __jsb_cc_Mesh_IStruct_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_IStruct) + +static bool js_cc_Mesh_IStruct_vertexBundles_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexBundles, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_vertexBundles_set) + +static bool js_cc_Mesh_IStruct_vertexBundles_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexBundles, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexBundles, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_vertexBundles_get) + +static bool js_cc_Mesh_IStruct_primitives_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitives, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_primitives_set) + +static bool js_cc_Mesh_IStruct_primitives_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitives, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitives, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_primitives_get) + +static bool js_cc_Mesh_IStruct_minPosition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minPosition, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_minPosition_set) + +static bool js_cc_Mesh_IStruct_minPosition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minPosition, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minPosition, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_minPosition_get) + +static bool js_cc_Mesh_IStruct_getMinPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< cc::Vec3 > *) &((cc::Mesh::IStruct const *)arg1)->getMinPosition(); + + 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_Mesh_IStruct_getMinPosition) + +static bool js_cc_Mesh_IStruct_setMinPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *arg2 = 0 ; + ccstd::optional< cc::Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMinPosition((ccstd::optional< cc::Vec3 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_IStruct_setMinPosition) + +static bool js_cc_Mesh_IStruct_maxPosition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxPosition, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_maxPosition_set) + +static bool js_cc_Mesh_IStruct_maxPosition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxPosition, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxPosition, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_maxPosition_get) + +static bool js_cc_Mesh_IStruct_getMaxPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::optional< cc::Vec3 > *) &((cc::Mesh::IStruct const *)arg1)->getMaxPosition(); + + 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_Mesh_IStruct_getMaxPosition) + +static bool js_cc_Mesh_IStruct_setMaxPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + ccstd::optional< cc::Vec3 > *arg2 = 0 ; + ccstd::optional< cc::Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMaxPosition((ccstd::optional< cc::Vec3 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_IStruct_setMaxPosition) + +static bool js_cc_Mesh_IStruct_jointMaps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->jointMaps, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_jointMaps_set) + +static bool js_cc_Mesh_IStruct_jointMaps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->jointMaps, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->jointMaps, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_jointMaps_get) + +static bool js_cc_Mesh_IStruct_morph_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->morph, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_morph_set) + +static bool js_cc_Mesh_IStruct_morph_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->morph, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->morph, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_morph_get) + +static bool js_cc_Mesh_IStruct_dynamic_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamic, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_dynamic_set) + +static bool js_cc_Mesh_IStruct_dynamic_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamic, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamic, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_dynamic_get) + +static bool js_cc_Mesh_IStruct_encoded_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->encoded, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_encoded_set) + +static bool js_cc_Mesh_IStruct_encoded_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->encoded, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->encoded, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_encoded_get) + +static bool js_cc_Mesh_IStruct_compressed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compressed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_compressed_set) + +static bool js_cc_Mesh_IStruct_compressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compressed, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->compressed, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_compressed_get) + +static bool js_cc_Mesh_IStruct_quantized_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->quantized, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_IStruct_quantized_set) + +static bool js_cc_Mesh_IStruct_quantized_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::IStruct *arg1 = (cc::Mesh::IStruct *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->quantized, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->quantized, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_IStruct_quantized_get) + +static bool js_new_cc_Mesh_IStruct(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::IStruct *result; + result = (cc::Mesh::IStruct *)new cc::Mesh::IStruct(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_IStruct, __jsb_cc_Mesh_IStruct_class, js_delete_cc_Mesh_IStruct) + +static bool js_delete_cc_Mesh_IStruct(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_IStruct) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IStruct * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vertexBundles", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexBundles), ctx); + } + + + json->getProperty("primitives", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitives), ctx); + } + + + json->getProperty("minPosition", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minPosition), ctx); + } + + + json->getProperty("maxPosition", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxPosition), ctx); + } + + + json->getProperty("jointMaps", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->jointMaps), ctx); + } + + + json->getProperty("morph", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->morph), ctx); + } + + + json->getProperty("dynamic", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamic), ctx); + } + + + json->getProperty("encoded", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->encoded), ctx); + } + + + json->getProperty("compressed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compressed), ctx); + } + + + json->getProperty("quantized", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->quantized), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_IStruct(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "IStruct"}, obj, nullptr, _SE(js_new_cc_Mesh_IStruct)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexBundles", _SE(js_cc_Mesh_IStruct_vertexBundles_get), _SE(js_cc_Mesh_IStruct_vertexBundles_set)); + cls->defineProperty("primitives", _SE(js_cc_Mesh_IStruct_primitives_get), _SE(js_cc_Mesh_IStruct_primitives_set)); + cls->defineProperty("minPosition", _SE(js_cc_Mesh_IStruct_minPosition_get), _SE(js_cc_Mesh_IStruct_minPosition_set)); + cls->defineProperty("maxPosition", _SE(js_cc_Mesh_IStruct_maxPosition_get), _SE(js_cc_Mesh_IStruct_maxPosition_set)); + cls->defineProperty("jointMaps", _SE(js_cc_Mesh_IStruct_jointMaps_get), _SE(js_cc_Mesh_IStruct_jointMaps_set)); + cls->defineProperty("morph", _SE(js_cc_Mesh_IStruct_morph_get), _SE(js_cc_Mesh_IStruct_morph_set)); + cls->defineProperty("dynamic", _SE(js_cc_Mesh_IStruct_dynamic_get), _SE(js_cc_Mesh_IStruct_dynamic_set)); + cls->defineProperty("encoded", _SE(js_cc_Mesh_IStruct_encoded_get), _SE(js_cc_Mesh_IStruct_encoded_set)); + cls->defineProperty("compressed", _SE(js_cc_Mesh_IStruct_compressed_get), _SE(js_cc_Mesh_IStruct_compressed_set)); + cls->defineProperty("quantized", _SE(js_cc_Mesh_IStruct_quantized_get), _SE(js_cc_Mesh_IStruct_quantized_set)); + + cls->defineFunction("getMinPosition", _SE(js_cc_Mesh_IStruct_getMinPosition)); + cls->defineFunction("setMinPosition", _SE(js_cc_Mesh_IStruct_setMinPosition)); + cls->defineFunction("getMaxPosition", _SE(js_cc_Mesh_IStruct_getMaxPosition)); + cls->defineFunction("setMaxPosition", _SE(js_cc_Mesh_IStruct_setMaxPosition)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_IStruct)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_IStruct_proto = cls->getProto(); + __jsb_cc_Mesh_IStruct_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mesh_ICreateInfo_class = nullptr; +se::Object* __jsb_cc_Mesh_ICreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mesh_ICreateInfo) + +static bool js_cc_Mesh_ICreateInfo_cpp_keyword_struct_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->structInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_set) + +static bool js_cc_Mesh_ICreateInfo_cpp_keyword_struct_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->structInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->structInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_get) + +static bool js_cc_Mesh_ICreateInfo_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_ICreateInfo_data_set) + +static bool js_cc_Mesh_ICreateInfo_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh::ICreateInfo *arg1 = (cc::Mesh::ICreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_ICreateInfo_data_get) + +static bool js_new_cc_Mesh_ICreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh::ICreateInfo *result; + result = (cc::Mesh::ICreateInfo *)new cc::Mesh::ICreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh_ICreateInfo, __jsb_cc_Mesh_ICreateInfo_class, js_delete_cc_Mesh_ICreateInfo) + +static bool js_delete_cc_Mesh_ICreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh_ICreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ICreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("struct", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->structInfo), ctx); + } + + + json->getProperty("data", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->data), ctx); + } + + + return ok; +} + + +bool js_register_cc_Mesh_ICreateInfo(se::Object* obj) { + auto* cls = se::Class::create({"Mesh", "ICreateInfo"}, obj, nullptr, _SE(js_new_cc_Mesh_ICreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("struct", _SE(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_get), _SE(js_cc_Mesh_ICreateInfo_cpp_keyword_struct_set)); + cls->defineProperty("data", _SE(js_cc_Mesh_ICreateInfo_data_get), _SE(js_cc_Mesh_ICreateInfo_data_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh_ICreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_ICreateInfo_proto = cls->getProto(); + __jsb_cc_Mesh_ICreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_new_cc_Mesh(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Mesh *result; + result = (cc::Mesh *)new cc::Mesh(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Mesh, __jsb_cc_Mesh_class, js_delete_cc_Mesh) + +static bool js_delete_cc_Mesh(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mesh) + +static bool js_cc_Mesh_getMinPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *)((cc::Mesh const *)arg1)->getMinPosition(); + + 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_Mesh_getMinPosition) + +static bool js_cc_Mesh_getMaxPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *)((cc::Mesh const *)arg1)->getMaxPosition(); + + 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_Mesh_getMaxPosition) + +static bool js_cc_Mesh_getStruct(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::IStruct *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(s); + if (nullptr == arg1) return true; + result = (cc::Mesh::IStruct *) &((cc::Mesh const *)arg1)->getStruct(); + + 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_Mesh_getStruct) + +static bool js_cc_Mesh_setStruct(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::IStruct *arg2 = 0 ; + cc::Mesh::IStruct temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStruct((cc::Mesh::IStruct const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_setStruct) + +static bool js_cc_Mesh_setData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Uint8Array *arg2 = 0 ; + cc::Uint8Array temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setData((cc::Uint8Array const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_setData) + +static bool js_cc_Mesh_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_initialize) + +static bool js_cc_Mesh_destroyRenderingMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyRenderingMesh(); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_destroyRenderingMesh) + +static bool js_cc_Mesh_assign(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::IStruct *arg2 = 0 ; + cc::Uint8Array *arg3 = 0 ; + cc::Mesh::IStruct temp2 ; + cc::Uint8Array temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->assign((cc::Mesh::IStruct const &)*arg2,(cc::Uint8Array const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_assign) + +static bool js_cc_Mesh_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::ICreateInfo *arg2 = 0 ; + cc::Mesh::ICreateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->reset((cc::Mesh::ICreateInfo &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_reset) + +static bool js_cc_Mesh_getBoneSpaceBounds(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Skeleton *arg2 = (cc::Skeleton *) NULL ; + cc::Mesh::BoneSpaceBounds result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getBoneSpaceBounds(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_getBoneSpaceBounds) + +static bool js_cc_Mesh_merge__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + cc::Mat4 *arg3 = (cc::Mat4 *) NULL ; + bool arg4 ; + cc::Mat4 temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (cc::Mat4 *) &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->merge(arg2,(cc::Mat4 const *)arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Mesh_merge__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + cc::Mat4 *arg3 = (cc::Mat4 *) NULL ; + cc::Mat4 temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (cc::Mat4 *) &temp3; + + result = (bool)(arg1)->merge(arg2,(cc::Mat4 const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Mesh_merge__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(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)->merge(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Mesh_merge(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Mesh_merge__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Mesh_merge__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Mesh_merge__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Mesh_merge) + +static bool js_cc_Mesh_validateMergingMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh *arg2 = (cc::Mesh *) 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(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)->validateMergingMesh(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_validateMergingMesh) + +static bool js_cc_Mesh_readAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + char *arg3 = (char *) NULL ; + ccstd::string temp3 ; + cc::TypedArray result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (arg1)->readAttribute(arg2,(char const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_readAttribute) + +static bool js_cc_Mesh_copyAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + char *arg3 = (char *) NULL ; + cc::ArrayBuffer *arg4 = (cc::ArrayBuffer *) NULL ; + uint32_t arg5 ; + uint32_t arg6 ; + ccstd::string temp3 ; + bool result; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + + 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 = (bool)(arg1)->copyAttribute(arg2,(char const *)arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_copyAttribute) + +static bool js_cc_Mesh_readIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + cc::IBArray result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->readIndices(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_readIndices) + +static bool js_cc_Mesh_copyIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + cc::TypedArray *arg3 = 0 ; + cc::TypedArray temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->copyIndices(arg2,*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_copyIndices) + +static bool js_cc_Mesh_readAttributeFormat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + char *arg3 = (char *) NULL ; + ccstd::string temp3 ; + cc::gfx::FormatInfo *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(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (cc::gfx::FormatInfo *)(arg1)->readAttributeFormat(arg2,(char 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_Mesh_readAttributeFormat) + +static bool js_cc_Mesh_updateSubMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + index_t arg2 ; + cc::IDynamicGeometry *arg3 = 0 ; + cc::IDynamicGeometry temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->updateSubMesh(arg2,(cc::IDynamicGeometry const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Mesh_updateSubMesh) + +static bool js_cc_Mesh_morphRendering_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->morphRendering, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_morphRendering_set) + +static bool js_cc_Mesh_morphRendering_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->morphRendering, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->morphRendering, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_morphRendering_get) + +static bool js_cc_Mesh__hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Mesh__hash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh__hash_set) + +static bool js_cc_Mesh__hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Mesh__hash_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_Mesh__hash_get) + +static bool js_cc_Mesh_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Mesh_hash_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_Mesh_hash_get) + +static bool js_cc_Mesh_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Uint8Array *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Uint8Array *) &cc_Mesh_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_data_get) + +static bool js_cc_Mesh__data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Uint8Array *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Uint8Array *) &cc_Mesh__data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh__data_get) + +static bool js_cc_Mesh_jointBufferIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::JointBufferIndicesType *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mesh::JointBufferIndicesType *) &cc_Mesh_jointBufferIndices_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_Mesh_jointBufferIndices_get) + +static bool js_cc_Mesh_renderingSubMeshes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::Mesh::RenderingSubMeshList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mesh::RenderingSubMeshList *) &cc_Mesh_renderingSubMeshes_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_Mesh_renderingSubMeshes_get) + +static bool js_cc_Mesh_subMeshCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Mesh_subMeshCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_subMeshCount_get) + +static bool js_cc_Mesh__nativeAsset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::ArrayBuffer *arg2 = (cc::ArrayBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Mesh__nativeAsset_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh__nativeAsset_set) + +static bool js_cc_Mesh__nativeAsset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + cc::ArrayBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)cc_Mesh__nativeAsset_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_Mesh__nativeAsset_get) + +static bool js_cc_Mesh__allowDataAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Mesh__allowDataAccess_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh__allowDataAccess_set) + +static bool js_cc_Mesh__allowDataAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Mesh__allowDataAccess_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh__allowDataAccess_get) + +static bool js_cc_Mesh_allowDataAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Mesh_allowDataAccess_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Mesh_allowDataAccess_set) + +static bool js_cc_Mesh_allowDataAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Mesh *arg1 = (cc::Mesh *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Mesh_allowDataAccess_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Mesh_allowDataAccess_get) + +bool js_register_cc_Mesh(se::Object* obj) { + auto* cls = se::Class::create("Mesh", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_Mesh)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("morphRendering", _SE(js_cc_Mesh_morphRendering_get), _SE(js_cc_Mesh_morphRendering_set)); + cls->defineProperty("_hash", _SE(js_cc_Mesh__hash_get), _SE(js_cc_Mesh__hash_set)); + cls->defineProperty("hash", _SE(js_cc_Mesh_hash_get), nullptr); + cls->defineProperty("data", _SE(js_cc_Mesh_data_get), nullptr); + cls->defineProperty("_data", _SE(js_cc_Mesh__data_get), nullptr); + cls->defineProperty("jointBufferIndices", _SE(js_cc_Mesh_jointBufferIndices_get), nullptr); + cls->defineProperty("renderingSubMeshes", _SE(js_cc_Mesh_renderingSubMeshes_get), nullptr); + cls->defineProperty("subMeshCount", _SE(js_cc_Mesh_subMeshCount_get), nullptr); + cls->defineProperty("_nativeAsset", _SE(js_cc_Mesh__nativeAsset_get), _SE(js_cc_Mesh__nativeAsset_set)); + cls->defineProperty("_allowDataAccess", _SE(js_cc_Mesh__allowDataAccess_get), _SE(js_cc_Mesh__allowDataAccess_set)); + cls->defineProperty("allowDataAccess", _SE(js_cc_Mesh_allowDataAccess_get), _SE(js_cc_Mesh_allowDataAccess_set)); + + cls->defineFunction("getMinPosition", _SE(js_cc_Mesh_getMinPosition)); + cls->defineFunction("getMaxPosition", _SE(js_cc_Mesh_getMaxPosition)); + cls->defineFunction("getStruct", _SE(js_cc_Mesh_getStruct)); + cls->defineFunction("setStruct", _SE(js_cc_Mesh_setStruct)); + cls->defineFunction("setData", _SE(js_cc_Mesh_setData)); + cls->defineFunction("initialize", _SE(js_cc_Mesh_initialize)); + cls->defineFunction("destroyRenderingMesh", _SE(js_cc_Mesh_destroyRenderingMesh)); + cls->defineFunction("assign", _SE(js_cc_Mesh_assign)); + cls->defineFunction("reset", _SE(js_cc_Mesh_reset)); + cls->defineFunction("getBoneSpaceBounds", _SE(js_cc_Mesh_getBoneSpaceBounds)); + cls->defineFunction("merge", _SE(js_cc_Mesh_merge)); + cls->defineFunction("validateMergingMesh", _SE(js_cc_Mesh_validateMergingMesh)); + cls->defineFunction("readAttribute", _SE(js_cc_Mesh_readAttribute)); + cls->defineFunction("copyAttribute", _SE(js_cc_Mesh_copyAttribute)); + cls->defineFunction("readIndices", _SE(js_cc_Mesh_readIndices)); + cls->defineFunction("copyIndices", _SE(js_cc_Mesh_copyIndices)); + cls->defineFunction("readAttributeFormat", _SE(js_cc_Mesh_readAttributeFormat)); + cls->defineFunction("updateSubMesh", _SE(js_cc_Mesh_updateSubMesh)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mesh)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mesh_proto = cls->getProto(); + __jsb_cc_Mesh_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Skeleton_class = nullptr; +se::Object* __jsb_cc_Skeleton_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Skeleton) + +static bool js_new_cc_Skeleton(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::Skeleton *result; + result = (cc::Skeleton *)new cc::Skeleton(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Skeleton, __jsb_cc_Skeleton_class, js_delete_cc_Skeleton) + +static bool js_delete_cc_Skeleton(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Skeleton) + +static bool js_cc_Skeleton__getBindposes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Mat4 > *) &((cc::Skeleton const *)arg1)->getBindposes(); + + 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_Skeleton__getBindposes) + +static bool js_cc_Skeleton__setBindposes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *arg2 = 0 ; + ccstd::vector< cc::Mat4 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setBindposes((ccstd::vector< cc::Mat4 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Skeleton__setBindposes) + +static bool js_cc_Skeleton_joints_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *arg2 = 0 ; + ccstd::vector< ccstd::string > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Skeleton_joints_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton_joints_set) + +static bool js_cc_Skeleton_joints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &cc_Skeleton_joints_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_Skeleton_joints_get) + +static bool js_cc_Skeleton__joints_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *arg2 = 0 ; + ccstd::vector< ccstd::string > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Skeleton__joints_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton__joints_set) + +static bool js_cc_Skeleton__joints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< ccstd::string > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &cc_Skeleton__joints_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_Skeleton__joints_get) + +static bool js_cc_Skeleton_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Skeleton_hash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton_hash_set) + +static bool js_cc_Skeleton_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Skeleton_hash_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_Skeleton_hash_get) + +static bool js_cc_Skeleton__hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Skeleton__hash_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Skeleton__hash_set) + +static bool js_cc_Skeleton__hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Skeleton__hash_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_Skeleton__hash_get) + +static bool js_cc_Skeleton__invBindposes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Mat4 > *) &cc_Skeleton__invBindposes_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_Skeleton__invBindposes_get) + +static bool js_cc_Skeleton_inverseBindposes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Skeleton *arg1 = (cc::Skeleton *) NULL ; + ccstd::vector< cc::Mat4 > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Mat4 > *) &cc_Skeleton_inverseBindposes_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_Skeleton_inverseBindposes_get) + +bool js_register_cc_Skeleton(se::Object* obj) { + auto* cls = se::Class::create("Skeleton", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_Skeleton)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("joints", _SE(js_cc_Skeleton_joints_get), _SE(js_cc_Skeleton_joints_set)); + cls->defineProperty("_joints", _SE(js_cc_Skeleton__joints_get), _SE(js_cc_Skeleton__joints_set)); + cls->defineProperty("hash", _SE(js_cc_Skeleton_hash_get), _SE(js_cc_Skeleton_hash_set)); + cls->defineProperty("_hash", _SE(js_cc_Skeleton__hash_get), _SE(js_cc_Skeleton__hash_set)); + cls->defineProperty("_invBindposes", _SE(js_cc_Skeleton__invBindposes_get), nullptr); + cls->defineProperty("inverseBindposes", _SE(js_cc_Skeleton_inverseBindposes_get), nullptr); + + cls->defineFunction("_getBindposes", _SE(js_cc_Skeleton__getBindposes)); + cls->defineFunction("_setBindposes", _SE(js_cc_Skeleton__setBindposes)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Skeleton)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Skeleton_proto = cls->getProto(); + __jsb_cc_Skeleton_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICreateMeshOptions_class = nullptr; +se::Object* __jsb_cc_ICreateMeshOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICreateMeshOptions) + +static bool js_cc_ICreateMeshOptions_calculateBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateMeshOptions *arg1 = (cc::ICreateMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->calculateBounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateMeshOptions_calculateBounds_set) + +static bool js_cc_ICreateMeshOptions_calculateBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateMeshOptions *arg1 = (cc::ICreateMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->calculateBounds, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->calculateBounds, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateMeshOptions_calculateBounds_get) + +static bool js_new_cc_ICreateMeshOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ICreateMeshOptions *result; + result = (cc::ICreateMeshOptions *)new cc::ICreateMeshOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ICreateMeshOptions, __jsb_cc_ICreateMeshOptions_class, js_delete_cc_ICreateMeshOptions) + +static bool js_delete_cc_ICreateMeshOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICreateMeshOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateMeshOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("calculateBounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->calculateBounds), ctx); + } + + + return ok; +} + + +bool js_register_cc_ICreateMeshOptions(se::Object* obj) { + auto* cls = se::Class::create("ICreateMeshOptions", obj, nullptr, _SE(js_new_cc_ICreateMeshOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("calculateBounds", _SE(js_cc_ICreateMeshOptions_calculateBounds_get), _SE(js_cc_ICreateMeshOptions_calculateBounds_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICreateMeshOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICreateMeshOptions_proto = cls->getProto(); + __jsb_cc_ICreateMeshOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICreateDynamicMeshOptions_class = nullptr; +se::Object* __jsb_cc_ICreateDynamicMeshOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICreateDynamicMeshOptions) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_set) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_get) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshVertices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_set) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshVertices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_get) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubMeshIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_set) + +static bool js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ICreateDynamicMeshOptions *arg1 = (cc::ICreateDynamicMeshOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubMeshIndices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_get) + +static bool js_new_cc_ICreateDynamicMeshOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ICreateDynamicMeshOptions *result; + result = (cc::ICreateDynamicMeshOptions *)new cc::ICreateDynamicMeshOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ICreateDynamicMeshOptions, __jsb_cc_ICreateDynamicMeshOptions_class, js_delete_cc_ICreateDynamicMeshOptions) + +static bool js_delete_cc_ICreateDynamicMeshOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICreateDynamicMeshOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateDynamicMeshOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxSubMeshes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshes), ctx); + } + + + json->getProperty("maxSubMeshVertices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshVertices), ctx); + } + + + json->getProperty("maxSubMeshIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubMeshIndices), ctx); + } + + + return ok; +} + + +bool js_register_cc_ICreateDynamicMeshOptions(se::Object* obj) { + auto* cls = se::Class::create("ICreateDynamicMeshOptions", obj, nullptr, _SE(js_new_cc_ICreateDynamicMeshOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxSubMeshes", _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_get), _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshes_set)); + cls->defineProperty("maxSubMeshVertices", _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_get), _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshVertices_set)); + cls->defineProperty("maxSubMeshIndices", _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_get), _SE(js_cc_ICreateDynamicMeshOptions_maxSubMeshIndices_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICreateDynamicMeshOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICreateDynamicMeshOptions_proto = cls->getProto(); + __jsb_cc_ICreateDynamicMeshOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MeshUtils_class = nullptr; +se::Object* __jsb_cc_MeshUtils_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MeshUtils) + +static bool js_cc_MeshUtils_createMesh_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IGeometry *arg1 = 0 ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + ccstd::optional< cc::ICreateMeshOptions > *arg3 = 0 ; + cc::IGeometry temp1 ; + ccstd::optional< cc::ICreateMeshOptions > temp3 ; + cc::Mesh *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::Mesh *)cc::MeshUtils::createMesh((cc::IGeometry const &)*arg1,arg2,(ccstd::optional< cc::ICreateMeshOptions > 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; +} + +static bool js_cc_MeshUtils_createMesh_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IGeometry *arg1 = 0 ; + cc::Mesh *arg2 = (cc::Mesh *) NULL ; + cc::IGeometry temp1 ; + cc::Mesh *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mesh *)cc::MeshUtils::createMesh((cc::IGeometry const &)*arg1,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_MeshUtils_createMesh_static__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::IGeometry *arg1 = 0 ; + cc::IGeometry temp1 ; + cc::Mesh *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mesh *)cc::MeshUtils::createMesh((cc::IGeometry const &)*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; +} + +static bool js_cc_MeshUtils_createMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_MeshUtils_createMesh_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MeshUtils_createMesh_static__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_MeshUtils_createMesh_static__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MeshUtils_createMesh_static) + +static bool js_cc_MeshUtils_createDynamicMesh_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + index_t arg1 ; + cc::IDynamicGeometry *arg2 = 0 ; + cc::Mesh *arg3 = (cc::Mesh *) NULL ; + ccstd::optional< cc::ICreateDynamicMeshOptions > *arg4 = 0 ; + cc::IDynamicGeometry temp2 ; + ccstd::optional< cc::ICreateDynamicMeshOptions > temp4 ; + cc::Mesh *result = 0 ; + + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::Mesh *)cc::MeshUtils::createDynamicMesh(SWIG_STD_MOVE(arg1),(cc::IDynamicGeometry const &)*arg2,arg3,(ccstd::optional< cc::ICreateDynamicMeshOptions > 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_MeshUtils_createDynamicMesh_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + index_t arg1 ; + cc::IDynamicGeometry *arg2 = 0 ; + cc::Mesh *arg3 = (cc::Mesh *) NULL ; + cc::IDynamicGeometry temp2 ; + cc::Mesh *result = 0 ; + + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mesh *)cc::MeshUtils::createDynamicMesh(SWIG_STD_MOVE(arg1),(cc::IDynamicGeometry 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; +} + +static bool js_cc_MeshUtils_createDynamicMesh_static__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + index_t arg1 ; + cc::IDynamicGeometry *arg2 = 0 ; + cc::IDynamicGeometry temp2 ; + cc::Mesh *result = 0 ; + + + 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::Mesh *)cc::MeshUtils::createDynamicMesh(SWIG_STD_MOVE(arg1),(cc::IDynamicGeometry 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; +} + +static bool js_cc_MeshUtils_createDynamicMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_MeshUtils_createDynamicMesh_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_MeshUtils_createDynamicMesh_static__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MeshUtils_createDynamicMesh_static__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MeshUtils_createDynamicMesh_static) + +static bool js_cc_MeshUtils_inflateMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = 0 ; + cc::Uint8Array *arg2 = 0 ; + cc::Mesh::IStruct temp1 ; + cc::Uint8Array temp2 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::MeshUtils::inflateMesh((cc::Mesh::IStruct const &)*arg1,*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MeshUtils_inflateMesh_static) + +static bool js_cc_MeshUtils_decodeMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = 0 ; + cc::Uint8Array *arg2 = 0 ; + cc::Mesh::IStruct temp1 ; + cc::Uint8Array temp2 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::MeshUtils::decodeMesh(*arg1,*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MeshUtils_decodeMesh_static) + +static bool js_cc_MeshUtils_dequantizeMesh_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Mesh::IStruct *arg1 = 0 ; + cc::Uint8Array *arg2 = 0 ; + cc::Mesh::IStruct temp1 ; + cc::Uint8Array temp2 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::MeshUtils::dequantizeMesh(*arg1,*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MeshUtils_dequantizeMesh_static) + +static bool js_new_cc_MeshUtils(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MeshUtils *result; + result = (cc::MeshUtils *)new cc::MeshUtils(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MeshUtils, __jsb_cc_MeshUtils_class, js_delete_cc_MeshUtils) + +static bool js_delete_cc_MeshUtils(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MeshUtils) + +bool js_register_cc_MeshUtils(se::Object* obj) { + auto* cls = se::Class::create("MeshUtils", obj, nullptr, _SE(js_new_cc_MeshUtils)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("createMesh", _SE(js_cc_MeshUtils_createMesh_static)); + cls->defineStaticFunction("createDynamicMesh", _SE(js_cc_MeshUtils_createDynamicMesh_static)); + cls->defineStaticFunction("inflateMesh", _SE(js_cc_MeshUtils_inflateMesh_static)); + cls->defineStaticFunction("decodeMesh", _SE(js_cc_MeshUtils_decodeMesh_static)); + cls->defineStaticFunction("dequantizeMesh", _SE(js_cc_MeshUtils_dequantizeMesh_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MeshUtils)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MeshUtils_proto = cls->getProto(); + __jsb_cc_MeshUtils_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_assets(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_Error(ns); + js_register_cc_BoundingBox(ns); + js_register_cc_VertexIdChannel(ns); + js_register_cc_NativeDep(ns); + js_register_cc_IGeometryOptions(ns); + js_register_cc_CustomAttribute(ns); + js_register_cc_IGeometry(ns); + js_register_cc_DynamicCustomAttribute(ns); + js_register_cc_IDynamicGeometry(ns); + js_register_cc_Asset(ns); + js_register_cc_TextureBase(ns); + js_register_cc_SimpleTexture(ns); + js_register_cc_ITexture2DSerializeData(ns); + js_register_cc_ITexture2DCreateInfo(ns); + js_register_cc_Texture2D(ns); + js_register_cc_ITextureCubeMipmap(ns); + js_register_cc_ITextureCubeSerializeMipmapData(ns); + js_register_cc_MipmapAtlasLayoutInfo(ns); + js_register_cc_TextureCubeMipmapAtlasInfo(ns); + js_register_cc_TextureCubeSerializeData(ns); + js_register_cc_TextureCube(ns); + js_register_cc_IRenderTextureCreateInfo(ns); + js_register_cc_RenderTexture(ns); + js_register_cc_BufferAsset(ns); + js_register_cc_IPropertyInfo(ns); + js_register_cc_RasterizerStateInfo(ns); + js_register_cc_DepthStencilStateInfo(ns); + js_register_cc_BlendTargetInfo(ns); + js_register_cc_BlendStateInfo(ns); + js_register_cc_IPassStates(ns); + js_register_cc_IPassInfoFull(ns); + js_register_cc_ITechniqueInfo(ns); + js_register_cc_IBlockInfo(ns); + js_register_cc_ISamplerTextureInfo(ns); + js_register_cc_ITextureInfo(ns); + js_register_cc_ISamplerInfo(ns); + js_register_cc_IBufferInfo(ns); + js_register_cc_IImageInfo(ns); + js_register_cc_IInputAttachmentInfo(ns); + js_register_cc_IAttributeInfo(ns); + js_register_cc_IDefineInfo(ns); + js_register_cc_IBuiltin(ns); + js_register_cc_IBuiltinInfo(ns); + js_register_cc_IBuiltins(ns); + js_register_cc_IDescriptorInfo(ns); + js_register_cc_IShaderSource(ns); + js_register_cc_IShaderInfo(ns); + js_register_cc_EffectAsset(ns); + js_register_cc_IMemoryImageSource(ns); + js_register_cc_ImageAsset(ns); + js_register_cc_SceneAsset(ns); + js_register_cc_TextAsset(ns); + js_register_cc_IMaterialInfo(ns); + js_register_cc_Material(ns); + js_register_cc_IGeometricInfo(ns); + js_register_cc_IFlatBuffer(ns); + js_register_cc_RenderingSubMesh(ns); + js_register_cc_BuiltinResMgr(ns); + js_register_cc_IMeshBufferView(ns); + js_register_cc_MorphTarget(ns); + js_register_cc_SubMeshMorph(ns); + js_register_cc_Morph(ns); + js_register_cc_MorphRenderingInstance(ns); + js_register_cc_MorphRendering(ns); + js_register_cc_StdMorphRendering(ns); + js_register_cc_Mesh(ns); + js_register_cc_Mesh_IVertexBundle(ns); + js_register_cc_Mesh_IMeshCluster(ns); + js_register_cc_Mesh_ISubMesh(ns); + js_register_cc_Mesh_IDynamicInfo(ns); + js_register_cc_Mesh_IDynamicStruct(ns); + js_register_cc_Mesh_IStruct(ns); + js_register_cc_Mesh_ICreateInfo(ns); + js_register_cc_Skeleton(ns); + js_register_cc_ICreateMeshOptions(ns); + js_register_cc_ICreateDynamicMeshOptions(ns); + js_register_cc_MeshUtils(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_assets_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_assets_auto.h new file mode 100644 index 0000000000..b3e745c3e2 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_assets_auto.h @@ -0,0 +1,666 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "core/assets/Asset.h" +#include "core/assets/BufferAsset.h" +#include "core/assets/EffectAsset.h" +#include "core/assets/ImageAsset.h" +#include "core/assets/Material.h" +#include "core/builtin/BuiltinResMgr.h" +#include "3d/assets/Morph.h" +#include "3d/assets/Mesh.h" +#include "3d/assets/Skeleton.h" +#include "3d/misc/CreateMesh.h" + + + +bool register_all_assets(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::Error); +extern se::Object *__jsb_cc_Error_proto; // NOLINT +extern se::Class * __jsb_cc_Error_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Error * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::BoundingBox); +extern se::Object *__jsb_cc_BoundingBox_proto; // NOLINT +extern se::Class * __jsb_cc_BoundingBox_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::BoundingBox * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::VertexIdChannel); +extern se::Object *__jsb_cc_VertexIdChannel_proto; // NOLINT +extern se::Class * __jsb_cc_VertexIdChannel_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::VertexIdChannel * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::NativeDep); +extern se::Object *__jsb_cc_NativeDep_proto; // NOLINT +extern se::Class * __jsb_cc_NativeDep_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::NativeDep * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IGeometryOptions); +extern se::Object *__jsb_cc_IGeometryOptions_proto; // NOLINT +extern se::Class * __jsb_cc_IGeometryOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometryOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::CustomAttribute); +extern se::Object *__jsb_cc_CustomAttribute_proto; // NOLINT +extern se::Class * __jsb_cc_CustomAttribute_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::CustomAttribute * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IGeometry); +extern se::Object *__jsb_cc_IGeometry_proto; // NOLINT +extern se::Class * __jsb_cc_IGeometry_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometry * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::DynamicCustomAttribute); +extern se::Object *__jsb_cc_DynamicCustomAttribute_proto; // NOLINT +extern se::Class * __jsb_cc_DynamicCustomAttribute_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::DynamicCustomAttribute * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IDynamicGeometry); +extern se::Object *__jsb_cc_IDynamicGeometry_proto; // NOLINT +extern se::Class * __jsb_cc_IDynamicGeometry_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDynamicGeometry * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Asset); +extern se::Object *__jsb_cc_Asset_proto; // NOLINT +extern se::Class * __jsb_cc_Asset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureBase); +extern se::Object *__jsb_cc_TextureBase_proto; // NOLINT +extern se::Class * __jsb_cc_TextureBase_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SimpleTexture); +extern se::Object *__jsb_cc_SimpleTexture_proto; // NOLINT +extern se::Class * __jsb_cc_SimpleTexture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ITexture2DSerializeData); +extern se::Object *__jsb_cc_ITexture2DSerializeData_proto; // NOLINT +extern se::Class * __jsb_cc_ITexture2DSerializeData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DSerializeData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITexture2DCreateInfo); +extern se::Object *__jsb_cc_ITexture2DCreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ITexture2DCreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITexture2DCreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Texture2D); +extern se::Object *__jsb_cc_Texture2D_proto; // NOLINT +extern se::Class * __jsb_cc_Texture2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ITextureCubeMipmap); +extern se::Object *__jsb_cc_ITextureCubeMipmap_proto; // NOLINT +extern se::Class * __jsb_cc_ITextureCubeMipmap_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeMipmap * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITextureCubeSerializeMipmapData); +extern se::Object *__jsb_cc_ITextureCubeSerializeMipmapData_proto; // NOLINT +extern se::Class * __jsb_cc_ITextureCubeSerializeMipmapData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureCubeSerializeMipmapData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MipmapAtlasLayoutInfo); +extern se::Object *__jsb_cc_MipmapAtlasLayoutInfo_proto; // NOLINT +extern se::Class * __jsb_cc_MipmapAtlasLayoutInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::MipmapAtlasLayoutInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureCubeMipmapAtlasInfo); +extern se::Object *__jsb_cc_TextureCubeMipmapAtlasInfo_proto; // NOLINT +extern se::Class * __jsb_cc_TextureCubeMipmapAtlasInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeMipmapAtlasInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureCubeSerializeData); +extern se::Object *__jsb_cc_TextureCubeSerializeData_proto; // NOLINT +extern se::Class * __jsb_cc_TextureCubeSerializeData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::TextureCubeSerializeData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::TextureCube); +extern se::Object *__jsb_cc_TextureCube_proto; // NOLINT +extern se::Class * __jsb_cc_TextureCube_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IRenderTextureCreateInfo); +extern se::Object *__jsb_cc_IRenderTextureCreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IRenderTextureCreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IRenderTextureCreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderTexture); +extern se::Object *__jsb_cc_RenderTexture_proto; // NOLINT +extern se::Class * __jsb_cc_RenderTexture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::BufferAsset); +extern se::Object *__jsb_cc_BufferAsset_proto; // NOLINT +extern se::Class * __jsb_cc_BufferAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IPropertyInfo); +extern se::Object *__jsb_cc_IPropertyInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IPropertyInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPropertyInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RasterizerStateInfo); +extern se::Object *__jsb_cc_RasterizerStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_RasterizerStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::RasterizerStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::DepthStencilStateInfo); +extern se::Object *__jsb_cc_DepthStencilStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_DepthStencilStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::DepthStencilStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::BlendTargetInfo); +extern se::Object *__jsb_cc_BlendTargetInfo_proto; // NOLINT +extern se::Class * __jsb_cc_BlendTargetInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendTargetInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::BlendStateInfo); +extern se::Object *__jsb_cc_BlendStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_BlendStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::BlendStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IPassStates); +extern se::Object *__jsb_cc_IPassStates_proto; // NOLINT +extern se::Class * __jsb_cc_IPassStates_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassStates * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IPassInfoFull); +extern se::Object *__jsb_cc_IPassInfoFull_proto; // NOLINT +extern se::Class * __jsb_cc_IPassInfoFull_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IPassInfoFull * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITechniqueInfo); +extern se::Object *__jsb_cc_ITechniqueInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ITechniqueInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITechniqueInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBlockInfo); +extern se::Object *__jsb_cc_IBlockInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IBlockInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBlockInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ISamplerTextureInfo); +extern se::Object *__jsb_cc_ISamplerTextureInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ISamplerTextureInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerTextureInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ITextureInfo); +extern se::Object *__jsb_cc_ITextureInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ITextureInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ITextureInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ISamplerInfo); +extern se::Object *__jsb_cc_ISamplerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ISamplerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISamplerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBufferInfo); +extern se::Object *__jsb_cc_IBufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IBufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IImageInfo); +extern se::Object *__jsb_cc_IImageInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IImageInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IImageInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IInputAttachmentInfo); +extern se::Object *__jsb_cc_IInputAttachmentInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IInputAttachmentInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IInputAttachmentInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IAttributeInfo); +extern se::Object *__jsb_cc_IAttributeInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IAttributeInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IAttributeInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IDefineInfo); +extern se::Object *__jsb_cc_IDefineInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IDefineInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBuiltin); +extern se::Object *__jsb_cc_IBuiltin_proto; // NOLINT +extern se::Class * __jsb_cc_IBuiltin_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltin * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBuiltinInfo); +extern se::Object *__jsb_cc_IBuiltinInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IBuiltinInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltinInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IBuiltins); +extern se::Object *__jsb_cc_IBuiltins_proto; // NOLINT +extern se::Class * __jsb_cc_IBuiltins_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IBuiltins * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IDescriptorInfo); +extern se::Object *__jsb_cc_IDescriptorInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IDescriptorInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDescriptorInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IShaderSource); +extern se::Object *__jsb_cc_IShaderSource_proto; // NOLINT +extern se::Class * __jsb_cc_IShaderSource_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderSource * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IShaderInfo); +extern se::Object *__jsb_cc_IShaderInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IShaderInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IShaderInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::EffectAsset); +extern se::Object *__jsb_cc_EffectAsset_proto; // NOLINT +extern se::Class * __jsb_cc_EffectAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMemoryImageSource); +extern se::Object *__jsb_cc_IMemoryImageSource_proto; // NOLINT +extern se::Class * __jsb_cc_IMemoryImageSource_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMemoryImageSource * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ImageAsset); +extern se::Object *__jsb_cc_ImageAsset_proto; // NOLINT +extern se::Class * __jsb_cc_ImageAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SceneAsset); +extern se::Object *__jsb_cc_SceneAsset_proto; // NOLINT +extern se::Class * __jsb_cc_SceneAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::TextAsset); +extern se::Object *__jsb_cc_TextAsset_proto; // NOLINT +extern se::Class * __jsb_cc_TextAsset_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMaterialInfo); +extern se::Object *__jsb_cc_IMaterialInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IMaterialInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Material); +extern se::Object *__jsb_cc_Material_proto; // NOLINT +extern se::Class * __jsb_cc_Material_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IGeometricInfo); +extern se::Object *__jsb_cc_IGeometricInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IGeometricInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IGeometricInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IFlatBuffer); +extern se::Object *__jsb_cc_IFlatBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_IFlatBuffer_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IFlatBuffer * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::RenderingSubMesh); +extern se::Object *__jsb_cc_RenderingSubMesh_proto; // NOLINT +extern se::Class * __jsb_cc_RenderingSubMesh_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::BuiltinResMgr); +extern se::Object *__jsb_cc_BuiltinResMgr_proto; // NOLINT +extern se::Class * __jsb_cc_BuiltinResMgr_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMeshBufferView); +extern se::Object *__jsb_cc_IMeshBufferView_proto; // NOLINT +extern se::Class * __jsb_cc_IMeshBufferView_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMeshBufferView * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphTarget); +extern se::Object *__jsb_cc_MorphTarget_proto; // NOLINT +extern se::Class * __jsb_cc_MorphTarget_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::MorphTarget * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::SubMeshMorph); +extern se::Object *__jsb_cc_SubMeshMorph_proto; // NOLINT +extern se::Class * __jsb_cc_SubMeshMorph_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::SubMeshMorph * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Morph); +extern se::Object *__jsb_cc_Morph_proto; // NOLINT +extern se::Class * __jsb_cc_Morph_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Morph * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphRenderingInstance); +extern se::Object *__jsb_cc_MorphRenderingInstance_proto; // NOLINT +extern se::Class * __jsb_cc_MorphRenderingInstance_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphRendering); +extern se::Object *__jsb_cc_MorphRendering_proto; // NOLINT +extern se::Class * __jsb_cc_MorphRendering_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::StdMorphRendering); +extern se::Object *__jsb_cc_StdMorphRendering_proto; // NOLINT +extern se::Class * __jsb_cc_StdMorphRendering_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IVertexBundle); +extern se::Object *__jsb_cc_Mesh_IVertexBundle_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IVertexBundle_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IVertexBundle * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IMeshCluster); +extern se::Object *__jsb_cc_Mesh_IMeshCluster_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IMeshCluster_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IMeshCluster * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::ISubMesh); +extern se::Object *__jsb_cc_Mesh_ISubMesh_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_ISubMesh_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ISubMesh * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IDynamicInfo); +extern se::Object *__jsb_cc_Mesh_IDynamicInfo_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IDynamicInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IDynamicStruct); +extern se::Object *__jsb_cc_Mesh_IDynamicStruct_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IDynamicStruct_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IDynamicStruct * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::IStruct); +extern se::Object *__jsb_cc_Mesh_IStruct_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_IStruct_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::IStruct * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh::ICreateInfo); +extern se::Object *__jsb_cc_Mesh_ICreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_ICreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::Mesh::ICreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::Mesh); +extern se::Object *__jsb_cc_Mesh_proto; // NOLINT +extern se::Class * __jsb_cc_Mesh_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Skeleton); +extern se::Object *__jsb_cc_Skeleton_proto; // NOLINT +extern se::Class * __jsb_cc_Skeleton_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ICreateMeshOptions); +extern se::Object *__jsb_cc_ICreateMeshOptions_proto; // NOLINT +extern se::Class * __jsb_cc_ICreateMeshOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateMeshOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ICreateDynamicMeshOptions); +extern se::Object *__jsb_cc_ICreateDynamicMeshOptions_proto; // NOLINT +extern se::Class * __jsb_cc_ICreateDynamicMeshOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ICreateDynamicMeshOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MeshUtils); +extern se::Object *__jsb_cc_MeshUtils_proto; // NOLINT +extern se::Class * __jsb_cc_MeshUtils_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_audio_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_audio_auto.cpp new file mode 100644 index 0000000000..14498c5ef2 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_audio_auto.cpp @@ -0,0 +1,1200 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_audio_auto.h" + + + +se::Class* __jsb_cc_AudioProfile_class = nullptr; +se::Object* __jsb_cc_AudioProfile_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_AudioProfile) + +static bool js_cc_AudioProfile_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_AudioProfile_name_set) + +static bool js_cc_AudioProfile_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_AudioProfile_name_get) + +static bool js_cc_AudioProfile_maxInstances_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxInstances, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_AudioProfile_maxInstances_set) + +static bool js_cc_AudioProfile_maxInstances_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxInstances, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_AudioProfile_maxInstances_get) + +static bool js_cc_AudioProfile_minDelay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minDelay, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_AudioProfile_minDelay_set) + +static bool js_cc_AudioProfile_minDelay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::AudioProfile *arg1 = (cc::AudioProfile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minDelay, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_AudioProfile_minDelay_get) + +static bool js_new_cc_AudioProfile(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::AudioProfile *result; + result = (cc::AudioProfile *)new cc::AudioProfile(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_AudioProfile, __jsb_cc_AudioProfile_class, js_delete_cc_AudioProfile) + +static bool js_delete_cc_AudioProfile(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_AudioProfile) + +bool js_register_cc_AudioProfile(se::Object* obj) { + auto* cls = se::Class::create("AudioProfile", obj, nullptr, _SE(js_new_cc_AudioProfile)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_AudioProfile_name_get), _SE(js_cc_AudioProfile_name_set)); + cls->defineProperty("maxInstances", _SE(js_cc_AudioProfile_maxInstances_get), _SE(js_cc_AudioProfile_maxInstances_set)); + cls->defineProperty("minDelay", _SE(js_cc_AudioProfile_minDelay_get), _SE(js_cc_AudioProfile_minDelay_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_AudioProfile)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_AudioProfile_proto = cls->getProto(); + __jsb_cc_AudioProfile_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_AudioEngine_class = nullptr; +se::Object* __jsb_cc_AudioEngine_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_AudioEngine) + +static bool js_cc_AudioEngine_lazyInit_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)cc::AudioEngine::lazyInit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_lazyInit_static) + +static bool js_cc_AudioEngine_end_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::end(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_end_static) + +static bool js_cc_AudioEngine_getDefaultProfile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::AudioProfile *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::AudioProfile *)cc::AudioEngine::getDefaultProfile(); + + 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_AudioEngine_getDefaultProfile_static) + +static bool js_cc_AudioEngine_play2d_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + bool arg2 ; + float arg3 ; + cc::AudioProfile *arg4 = (cc::AudioProfile *) NULL ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1,arg2,arg3,(cc::AudioProfile const *)arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + bool arg2 ; + float arg3 ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + bool arg2 ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + int result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (int)cc::AudioEngine::play2d((ccstd::string const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_AudioEngine_play2d_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_AudioEngine_play2d_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_AudioEngine_play2d_static__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_AudioEngine_play2d_static__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_AudioEngine_play2d_static__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_AudioEngine_play2d_static) + +static bool js_cc_AudioEngine_setLoop_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + bool arg2 ; + + 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], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::AudioEngine::setLoop(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setLoop_static) + +static bool js_cc_AudioEngine_isLoop_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::AudioEngine::isLoop(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_isLoop_static) + +static bool js_cc_AudioEngine_setVolume_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float arg2 ; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::AudioEngine::setVolume(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setVolume_static) + +static bool js_cc_AudioEngine_setVolumeFactor_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::AudioEngine::setVolumeFactor(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setVolumeFactor_static) + +static bool js_cc_AudioEngine_getVolume_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::AudioEngine::getVolume(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getVolume_static) + +static bool js_cc_AudioEngine_pause_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + + 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::AudioEngine::pause(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_pause_static) + +static bool js_cc_AudioEngine_pauseAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::pauseAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_pauseAll_static) + +static bool js_cc_AudioEngine_resume_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + + 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::AudioEngine::resume(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_resume_static) + +static bool js_cc_AudioEngine_resumeAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::resumeAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_resumeAll_static) + +static bool js_cc_AudioEngine_stop_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + + 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::AudioEngine::stop(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_stop_static) + +static bool js_cc_AudioEngine_stopAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::stopAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_stopAll_static) + +static bool js_cc_AudioEngine_setCurrentTime_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float arg2 ; + bool result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::AudioEngine::setCurrentTime(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setCurrentTime_static) + +static bool js_cc_AudioEngine_getCurrentTime_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::AudioEngine::getCurrentTime(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getCurrentTime_static) + +static bool js_cc_AudioEngine_getDuration_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::AudioEngine::getDuration(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getDuration_static) + +static bool js_cc_AudioEngine_getDurationFromFile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (float)cc::AudioEngine::getDurationFromFile((ccstd::string const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getDurationFromFile_static) + +static bool js_cc_AudioEngine_getState_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + cc::AudioEngine::AudioState result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::AudioEngine::AudioState)cc::AudioEngine::getState(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_FUNC(js_cc_AudioEngine_getState_static) + +static bool js_cc_AudioEngine_setFinishCallback_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + std::function< void (int,ccstd::string const &) > *arg2 = 0 ; + std::function< void (int,ccstd::string const &) > temp2 ; + + 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; + + cc::AudioEngine::setFinishCallback(arg1,(std::function< void (int,ccstd::string const &) > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setFinishCallback_static) + +static bool js_cc_AudioEngine_getMaxAudioInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (int)cc::AudioEngine::getMaxAudioInstance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getMaxAudioInstance_static) + +static bool js_cc_AudioEngine_setMaxAudioInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::AudioEngine::setMaxAudioInstance(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setMaxAudioInstance_static) + +static bool js_cc_AudioEngine_uncache_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + cc::AudioEngine::uncache((ccstd::string const &)*arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_uncache_static) + +static bool js_cc_AudioEngine_uncacheAll_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::AudioEngine::uncacheAll(); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_uncacheAll_static) + +static bool js_cc_AudioEngine_getProfile_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + int arg1 ; + cc::AudioProfile *result = 0 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::AudioProfile *)cc::AudioEngine::getProfile(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; +} + +static bool js_cc_AudioEngine_getProfile_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::AudioProfile *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::AudioProfile *)cc::AudioEngine::getProfile((ccstd::string const &)*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; +} + +static bool js_cc_AudioEngine_getProfile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_AudioEngine_getProfile_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_AudioEngine_getProfile_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_AudioEngine_getProfile_static) + +static bool js_cc_AudioEngine_preload_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + cc::AudioEngine::preload((ccstd::string const &)*arg1); + + + return true; +} + +static bool js_cc_AudioEngine_preload_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + ccstd::string *arg1 = 0 ; + std::function< void (bool) > *arg2 = 0 ; + ccstd::string temp1 ; + std::function< void (bool) > temp2 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc::AudioEngine::preload((ccstd::string const &)*arg1,(std::function< void (bool) > const &)*arg2); + + + return true; +} + +static bool js_cc_AudioEngine_preload_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_AudioEngine_preload_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_AudioEngine_preload_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_AudioEngine_preload_static) + +static bool js_cc_AudioEngine_getPlayingAudioCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (int)cc::AudioEngine::getPlayingAudioCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_getPlayingAudioCount_static) + +static bool js_cc_AudioEngine_setEnabled_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::AudioEngine::setEnabled(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_setEnabled_static) + +static bool js_cc_AudioEngine_isEnabled_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)cc::AudioEngine::isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_AudioEngine_isEnabled_static) + +static bool js_new_cc_AudioEngine(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::AudioEngine *result; + result = (cc::AudioEngine *)new cc::AudioEngine(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_AudioEngine, __jsb_cc_AudioEngine_class, js_delete_cc_AudioEngine) + +static bool js_delete_cc_AudioEngine(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_AudioEngine) + +bool js_register_cc_AudioEngine(se::Object* obj) { + auto* cls = se::Class::create("AudioEngine", obj, nullptr, _SE(js_new_cc_AudioEngine)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("lazyInit", _SE(js_cc_AudioEngine_lazyInit_static)); + cls->defineStaticFunction("end", _SE(js_cc_AudioEngine_end_static)); + cls->defineStaticFunction("getDefaultProfile", _SE(js_cc_AudioEngine_getDefaultProfile_static)); + cls->defineStaticFunction("play2d", _SE(js_cc_AudioEngine_play2d_static)); + cls->defineStaticFunction("setLoop", _SE(js_cc_AudioEngine_setLoop_static)); + cls->defineStaticFunction("isLoop", _SE(js_cc_AudioEngine_isLoop_static)); + cls->defineStaticFunction("setVolume", _SE(js_cc_AudioEngine_setVolume_static)); + cls->defineStaticFunction("setVolumeFactor", _SE(js_cc_AudioEngine_setVolumeFactor_static)); + cls->defineStaticFunction("getVolume", _SE(js_cc_AudioEngine_getVolume_static)); + cls->defineStaticFunction("pause", _SE(js_cc_AudioEngine_pause_static)); + cls->defineStaticFunction("pauseAll", _SE(js_cc_AudioEngine_pauseAll_static)); + cls->defineStaticFunction("resume", _SE(js_cc_AudioEngine_resume_static)); + cls->defineStaticFunction("resumeAll", _SE(js_cc_AudioEngine_resumeAll_static)); + cls->defineStaticFunction("stop", _SE(js_cc_AudioEngine_stop_static)); + cls->defineStaticFunction("stopAll", _SE(js_cc_AudioEngine_stopAll_static)); + cls->defineStaticFunction("setCurrentTime", _SE(js_cc_AudioEngine_setCurrentTime_static)); + cls->defineStaticFunction("getCurrentTime", _SE(js_cc_AudioEngine_getCurrentTime_static)); + cls->defineStaticFunction("getDuration", _SE(js_cc_AudioEngine_getDuration_static)); + cls->defineStaticFunction("getDurationFromFile", _SE(js_cc_AudioEngine_getDurationFromFile_static)); + cls->defineStaticFunction("getState", _SE(js_cc_AudioEngine_getState_static)); + cls->defineStaticFunction("setFinishCallback", _SE(js_cc_AudioEngine_setFinishCallback_static)); + cls->defineStaticFunction("getMaxAudioInstance", _SE(js_cc_AudioEngine_getMaxAudioInstance_static)); + cls->defineStaticFunction("setMaxAudioInstance", _SE(js_cc_AudioEngine_setMaxAudioInstance_static)); + cls->defineStaticFunction("uncache", _SE(js_cc_AudioEngine_uncache_static)); + cls->defineStaticFunction("uncacheAll", _SE(js_cc_AudioEngine_uncacheAll_static)); + cls->defineStaticFunction("getProfile", _SE(js_cc_AudioEngine_getProfile_static)); + cls->defineStaticFunction("preload", _SE(js_cc_AudioEngine_preload_static)); + cls->defineStaticFunction("getPlayingAudioCount", _SE(js_cc_AudioEngine_getPlayingAudioCount_static)); + cls->defineStaticFunction("setEnabled", _SE(js_cc_AudioEngine_setEnabled_static)); + cls->defineStaticFunction("isEnabled", _SE(js_cc_AudioEngine_isEnabled_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_AudioEngine)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_AudioEngine_proto = cls->getProto(); + __jsb_cc_AudioEngine_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_audio(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_AudioProfile(ns); + js_register_cc_AudioEngine(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_audio_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_audio_auto.h new file mode 100644 index 0000000000..d68b2ac375 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_audio_auto.h @@ -0,0 +1,54 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "audio/include/AudioEngine.h" + + + +bool register_all_audio(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::AudioProfile); +extern se::Object *__jsb_cc_AudioProfile_proto; // NOLINT +extern se::Class * __jsb_cc_AudioProfile_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::AudioEngine); +extern se::Object *__jsb_cc_AudioEngine_proto; // NOLINT +extern se::Class * __jsb_cc_AudioEngine_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_box2d_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_box2d_auto.cpp new file mode 100644 index 0000000000..9c6acf4496 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_box2d_auto.cpp @@ -0,0 +1,24966 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_box2d_auto.h" + +#define SWIGINTERN static + + + +static bool js_b2IsValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)b2IsValid(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2IsValid) + +se::Class* __jsb_b2Vec2_class = nullptr; +se::Object* __jsb_b2Vec2_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Vec2) + +static bool js_new_b2Vec2__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec2 *result; + result = (b2Vec2 *)new b2Vec2(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec2__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + b2Vec2 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Vec2 *)new b2Vec2(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec2(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Vec2__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_b2Vec2__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec2"); + return false; +} +SE_BIND_CTOR(js_new_b2Vec2, __jsb_b2Vec2_class, js_delete_b2Vec2) + +static bool js_Vec2_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Vec2_SetZero) + +static bool js_Vec2_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Vec2_Set) + +static bool js_Vec2_Length(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Vec2 const *)arg1)->Length(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_Length) + +static bool js_Vec2_LengthSquared(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Vec2 const *)arg1)->LengthSquared(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_LengthSquared) + +static bool js_Vec2_Normalize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->Normalize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_Normalize) + +static bool js_Vec2_IsValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Vec2 const *)arg1)->IsValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Vec2_IsValid) + +static bool js_Vec2_Skew(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Vec2 const *)arg1)->Skew(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Vec2_Skew) + +static bool js_Vec2_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec2_x_set) + +static bool js_Vec2_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec2_x_get) + +static bool js_Vec2_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec2_y_set) + +static bool js_Vec2_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = (b2Vec2 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec2_y_get) + +static bool js_delete_b2Vec2(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Vec2) + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec2 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + return ok; +} + + +bool js_register_b2Vec2(se::Object* obj) { + auto* cls = se::Class::create("Vec2", obj, nullptr, _SE(js_new_b2Vec2)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_Vec2_x_get), _SE(js_Vec2_x_set)); + cls->defineProperty("y", _SE(js_Vec2_y_get), _SE(js_Vec2_y_set)); + + cls->defineFunction("SetZero", _SE(js_Vec2_SetZero)); + cls->defineFunction("Set", _SE(js_Vec2_Set)); + cls->defineFunction("Length", _SE(js_Vec2_Length)); + cls->defineFunction("LengthSquared", _SE(js_Vec2_LengthSquared)); + cls->defineFunction("Normalize", _SE(js_Vec2_Normalize)); + cls->defineFunction("IsValid", _SE(js_Vec2_IsValid)); + cls->defineFunction("Skew", _SE(js_Vec2_Skew)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Vec2)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Vec2_proto = cls->getProto(); + __jsb_b2Vec2_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Vec3_class = nullptr; +se::Object* __jsb_b2Vec3_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Vec3) + +static bool js_new_b2Vec3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec3 *result; + result = (b2Vec3 *)new b2Vec3(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + b2Vec3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Vec3 *)new b2Vec3(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Vec3(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Vec3__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_b2Vec3__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec3"); + return false; +} +SE_BIND_CTOR(js_new_b2Vec3, __jsb_b2Vec3_class, js_delete_b2Vec3) + +static bool js_Vec3_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Vec3_SetZero) + +static bool js_Vec3_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Vec3_Set) + +static bool js_Vec3_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec3_x_set) + +static bool js_Vec3_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec3_x_get) + +static bool js_Vec3_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec3_y_set) + +static bool js_Vec3_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec3_y_get) + +static bool js_Vec3_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Vec3_z_set) + +static bool js_Vec3_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = (b2Vec3 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Vec3_z_get) + +static bool js_delete_b2Vec3(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Vec3) + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec3 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + return ok; +} + + +bool js_register_b2Vec3(se::Object* obj) { + auto* cls = se::Class::create("Vec3", obj, nullptr, _SE(js_new_b2Vec3)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_Vec3_x_get), _SE(js_Vec3_x_set)); + cls->defineProperty("y", _SE(js_Vec3_y_get), _SE(js_Vec3_y_set)); + cls->defineProperty("z", _SE(js_Vec3_z_get), _SE(js_Vec3_z_set)); + + cls->defineFunction("SetZero", _SE(js_Vec3_SetZero)); + cls->defineFunction("Set", _SE(js_Vec3_Set)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Vec3)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Vec3_proto = cls->getProto(); + __jsb_b2Vec3_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Mat22_class = nullptr; +se::Object* __jsb_b2Mat22_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Mat22) + +static bool js_new_b2Mat22__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Mat22 *result; + result = (b2Mat22 *)new b2Mat22(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat22__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Mat22 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (b2Mat22 *)new b2Mat22((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat22__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + b2Mat22 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Mat22 *)new b2Mat22(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat22(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Mat22__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_b2Mat22__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_b2Mat22__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat22"); + return false; +} +SE_BIND_CTOR(js_new_b2Mat22, __jsb_b2Mat22_class, js_delete_b2Mat22) + +static bool js_Mat22_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_Mat22_Set) + +static bool js_Mat22_SetIdentity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetIdentity(); + + + return true; +} +SE_BIND_FUNC(js_Mat22_SetIdentity) + +static bool js_Mat22_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Mat22_SetZero) + +static bool js_Mat22_GetInverse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + b2Mat22 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Mat22 const *)arg1)->GetInverse(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat22_GetInverse) + +static bool js_Mat22_Solve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Mat22 const *)arg1)->Solve((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat22_Solve) + +static bool js_Mat22_ex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat22_ex_set) + +static bool js_Mat22_ex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat22_ex_get) + +static bool js_Mat22_ey_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ey, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat22_ey_set) + +static bool js_Mat22_ey_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat22 *arg1 = (b2Mat22 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ey, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ey, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat22_ey_get) + +static bool js_delete_b2Mat22(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Mat22) + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat22 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("ex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ex), ctx); + } + + + json->getProperty("ey", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ey), ctx); + } + + + return ok; +} + + +bool js_register_b2Mat22(se::Object* obj) { + auto* cls = se::Class::create("Mat22", obj, nullptr, _SE(js_new_b2Mat22)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("ex", _SE(js_Mat22_ex_get), _SE(js_Mat22_ex_set)); + cls->defineProperty("ey", _SE(js_Mat22_ey_get), _SE(js_Mat22_ey_set)); + + cls->defineFunction("Set", _SE(js_Mat22_Set)); + cls->defineFunction("SetIdentity", _SE(js_Mat22_SetIdentity)); + cls->defineFunction("SetZero", _SE(js_Mat22_SetZero)); + cls->defineFunction("GetInverse", _SE(js_Mat22_GetInverse)); + cls->defineFunction("Solve", _SE(js_Mat22_Solve)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Mat22)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Mat22_proto = cls->getProto(); + __jsb_b2Mat22_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Mat33_class = nullptr; +se::Object* __jsb_b2Mat33_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Mat33) + +static bool js_new_b2Mat33__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Mat33 *result; + result = (b2Mat33 *)new b2Mat33(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat33__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec3 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Vec3 *arg3 = 0 ; + b2Vec3 temp1 ; + b2Vec3 temp2 ; + b2Vec3 temp3 ; + b2Mat33 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (b2Mat33 *)new b2Mat33((b2Vec3 const &)*arg1,(b2Vec3 const &)*arg2,(b2Vec3 const &)*arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Mat33(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Mat33__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_b2Mat33__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat33"); + return false; +} +SE_BIND_CTOR(js_new_b2Mat33, __jsb_b2Mat33_class, js_delete_b2Mat33) + +static bool js_Mat33_SetZero(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetZero(); + + + return true; +} +SE_BIND_FUNC(js_Mat33_SetZero) + +static bool js_Mat33_Solve33(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Vec3 *arg2 = 0 ; + b2Vec3 temp2 ; + b2Vec3 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Mat33 const *)arg1)->Solve33((b2Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat33_Solve33) + +static bool js_Mat33_Solve22(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Mat33 const *)arg1)->Solve22((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Mat33_Solve22) + +static bool js_Mat33_GetInverse22(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Mat33 *arg2 = (b2Mat33 *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Mat33 const *)arg1)->GetInverse22(arg2); + + + return true; +} +SE_BIND_FUNC(js_Mat33_GetInverse22) + +static bool js_Mat33_GetSymInverse33(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + b2Mat33 *arg2 = (b2Mat33 *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Mat33 const *)arg1)->GetSymInverse33(arg2); + + + return true; +} +SE_BIND_FUNC(js_Mat33_GetSymInverse33) + +static bool js_Mat33_ex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat33_ex_set) + +static bool js_Mat33_ex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat33_ex_get) + +static bool js_Mat33_ey_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ey, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat33_ey_set) + +static bool js_Mat33_ey_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ey, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ey, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat33_ey_get) + +static bool js_Mat33_ez_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ez, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Mat33_ez_set) + +static bool js_Mat33_ez_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Mat33 *arg1 = (b2Mat33 *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ez, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ez, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Mat33_ez_get) + +static bool js_delete_b2Mat33(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Mat33) + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat33 * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("ex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ex), ctx); + } + + + json->getProperty("ey", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ey), ctx); + } + + + json->getProperty("ez", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ez), ctx); + } + + + return ok; +} + + +bool js_register_b2Mat33(se::Object* obj) { + auto* cls = se::Class::create("Mat33", obj, nullptr, _SE(js_new_b2Mat33)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("ex", _SE(js_Mat33_ex_get), _SE(js_Mat33_ex_set)); + cls->defineProperty("ey", _SE(js_Mat33_ey_get), _SE(js_Mat33_ey_set)); + cls->defineProperty("ez", _SE(js_Mat33_ez_get), _SE(js_Mat33_ez_set)); + + cls->defineFunction("SetZero", _SE(js_Mat33_SetZero)); + cls->defineFunction("Solve33", _SE(js_Mat33_Solve33)); + cls->defineFunction("Solve22", _SE(js_Mat33_Solve22)); + cls->defineFunction("GetInverse22", _SE(js_Mat33_GetInverse22)); + cls->defineFunction("GetSymInverse33", _SE(js_Mat33_GetSymInverse33)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Mat33)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Mat33_proto = cls->getProto(); + __jsb_b2Mat33_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Rot_class = nullptr; +se::Object* __jsb_b2Rot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Rot) + +static bool js_new_b2Rot__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Rot *result; + result = (b2Rot *)new b2Rot(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Rot__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + b2Rot *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Rot *)new b2Rot(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Rot(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Rot__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_b2Rot__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Rot"); + return false; +} +SE_BIND_CTOR(js_new_b2Rot, __jsb_b2Rot_class, js_delete_b2Rot) + +static bool js_Rot_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Set(arg2); + + + return true; +} +SE_BIND_FUNC(js_Rot_Set) + +static bool js_Rot_SetIdentity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetIdentity(); + + + return true; +} +SE_BIND_FUNC(js_Rot_SetIdentity) + +static bool js_Rot_GetAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Rot const *)arg1)->GetAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Rot_GetAngle) + +static bool js_Rot_GetXAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Rot const *)arg1)->GetXAxis(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Rot_GetXAxis) + +static bool js_Rot_GetYAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Rot const *)arg1)->GetYAxis(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Rot_GetYAxis) + +static bool js_Rot_s_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->s, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Rot_s_set) + +static bool js_Rot_s_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->s, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Rot_s_get) + +static bool js_Rot_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Rot_c_set) + +static bool js_Rot_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Rot *arg1 = (b2Rot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Rot_c_get) + +static bool js_delete_b2Rot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Rot) + +template<> +bool sevalue_to_native(const se::Value &from, b2Rot * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("s", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->s), ctx); + } + + + json->getProperty("c", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c), ctx); + } + + + return ok; +} + + +bool js_register_b2Rot(se::Object* obj) { + auto* cls = se::Class::create("Rot", obj, nullptr, _SE(js_new_b2Rot)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("s", _SE(js_Rot_s_get), _SE(js_Rot_s_set)); + cls->defineProperty("c", _SE(js_Rot_c_get), _SE(js_Rot_c_set)); + + cls->defineFunction("Set", _SE(js_Rot_Set)); + cls->defineFunction("SetIdentity", _SE(js_Rot_SetIdentity)); + cls->defineFunction("GetAngle", _SE(js_Rot_GetAngle)); + cls->defineFunction("GetXAxis", _SE(js_Rot_GetXAxis)); + cls->defineFunction("GetYAxis", _SE(js_Rot_GetYAxis)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Rot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Rot_proto = cls->getProto(); + __jsb_b2Rot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Transform_class = nullptr; +se::Object* __jsb_b2Transform_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Transform) + +static bool js_new_b2Transform__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Transform *result; + result = (b2Transform *)new b2Transform(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Transform__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Vec2 *arg1 = 0 ; + b2Rot *arg2 = 0 ; + b2Vec2 temp1 ; + b2Rot temp2 ; + b2Transform *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (b2Transform *)new b2Transform((b2Vec2 const &)*arg1,(b2Rot const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Transform(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Transform__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_b2Transform__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Transform"); + return false; +} +SE_BIND_CTOR(js_new_b2Transform, __jsb_b2Transform_class, js_delete_b2Transform) + +static bool js_Transform_SetIdentity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->SetIdentity(); + + + return true; +} +SE_BIND_FUNC(js_Transform_SetIdentity) + +static bool js_Transform_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Set((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Transform_Set) + +static bool js_Transform_p_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->p, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Transform_p_set) + +static bool js_Transform_p_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->p, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->p, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Transform_p_get) + +static bool js_Transform_q_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->q, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Transform_q_set) + +static bool js_Transform_q_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Transform *arg1 = (b2Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->q, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->q, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Transform_q_get) + +static bool js_delete_b2Transform(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Transform) + +template<> +bool sevalue_to_native(const se::Value &from, b2Transform * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("p", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->p), ctx); + } + + + json->getProperty("q", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->q), ctx); + } + + + return ok; +} + + +bool js_register_b2Transform(se::Object* obj) { + auto* cls = se::Class::create("Transform", obj, nullptr, _SE(js_new_b2Transform)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("p", _SE(js_Transform_p_get), _SE(js_Transform_p_set)); + cls->defineProperty("q", _SE(js_Transform_q_get), _SE(js_Transform_q_set)); + + cls->defineFunction("SetIdentity", _SE(js_Transform_SetIdentity)); + cls->defineFunction("Set", _SE(js_Transform_Set)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Transform)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Transform_proto = cls->getProto(); + __jsb_b2Transform_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Sweep_class = nullptr; +se::Object* __jsb_b2Sweep_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Sweep) + +static bool js_Sweep_GetTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + b2Transform *arg2 = (b2Transform *) NULL ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + ((b2Sweep const *)arg1)->GetTransform(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Sweep_GetTransform) + +static bool js_Sweep_Advance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Advance(arg2); + + + return true; +} +SE_BIND_FUNC(js_Sweep_Advance) + +static bool js_Sweep_Normalize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Normalize(); + + + return true; +} +SE_BIND_FUNC(js_Sweep_Normalize) + +static bool js_Sweep_localCenter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localCenter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_localCenter_set) + +static bool js_Sweep_localCenter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localCenter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localCenter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_localCenter_get) + +static bool js_Sweep_c0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_c0_set) + +static bool js_Sweep_c0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c0, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c0, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_c0_get) + +static bool js_Sweep_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_c_set) + +static bool js_Sweep_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_c_get) + +static bool js_Sweep_a0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_a0_set) + +static bool js_Sweep_a0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a0, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_a0_get) + +static bool js_Sweep_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_a_set) + +static bool js_Sweep_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_a_get) + +static bool js_Sweep_alpha0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->alpha0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Sweep_alpha0_set) + +static bool js_Sweep_alpha0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Sweep *arg1 = (b2Sweep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->alpha0, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Sweep_alpha0_get) + +static bool js_new_b2Sweep(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Sweep *result; + result = (b2Sweep *)new b2Sweep(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Sweep, __jsb_b2Sweep_class, js_delete_b2Sweep) + +static bool js_delete_b2Sweep(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Sweep) + +template<> +bool sevalue_to_native(const se::Value &from, b2Sweep * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localCenter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localCenter), ctx); + } + + + json->getProperty("c0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c0), ctx); + } + + + json->getProperty("c", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c), ctx); + } + + + json->getProperty("a0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a0), ctx); + } + + + json->getProperty("a", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a), ctx); + } + + + json->getProperty("alpha0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->alpha0), ctx); + } + + + return ok; +} + + +bool js_register_b2Sweep(se::Object* obj) { + auto* cls = se::Class::create("Sweep", obj, nullptr, _SE(js_new_b2Sweep)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localCenter", _SE(js_Sweep_localCenter_get), _SE(js_Sweep_localCenter_set)); + cls->defineProperty("c0", _SE(js_Sweep_c0_get), _SE(js_Sweep_c0_set)); + cls->defineProperty("c", _SE(js_Sweep_c_get), _SE(js_Sweep_c_set)); + cls->defineProperty("a0", _SE(js_Sweep_a0_get), _SE(js_Sweep_a0_set)); + cls->defineProperty("a", _SE(js_Sweep_a_get), _SE(js_Sweep_a_set)); + cls->defineProperty("alpha0", _SE(js_Sweep_alpha0_get), _SE(js_Sweep_alpha0_set)); + + cls->defineFunction("GetTransform", _SE(js_Sweep_GetTransform)); + cls->defineFunction("Advance", _SE(js_Sweep_Advance)); + cls->defineFunction("Normalize", _SE(js_Sweep_Normalize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Sweep)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Sweep_proto = cls->getProto(); + __jsb_b2Sweep_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_b2Dot__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Dot((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2Cross__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Cross((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2Cross__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + float arg2 ; + b2Vec2 temp1 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = b2Cross((b2Vec2 const &)*arg1,arg2); + + 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; +} + +static bool js_b2Cross__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + float arg1 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + 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 = b2Cross(arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Mat22 const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Mat22 const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Distance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Distance((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2Distance) + +static bool js_b2DistanceSquared(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + float result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2DistanceSquared((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2DistanceSquared) + +static bool js_b2Dot__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec3 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Vec3 temp1 ; + b2Vec3 temp2 ; + float result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (float)b2Dot((b2Vec3 const &)*arg1,(b2Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2Dot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2Dot__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Dot__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Dot) + +static bool js_b2Cross__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec3 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Vec3 temp1 ; + b2Vec3 temp2 ; + b2Vec3 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Cross((b2Vec3 const &)*arg1,(b2Vec3 const &)*arg2); + + 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; +} + +static bool js_b2Cross(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2Cross__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Cross__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Cross__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Cross__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Cross) + +static bool js_b2Mul__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Mat22 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Mat22 temp2 ; + b2Mat22 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Mat22 const &)*arg1,(b2Mat22 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Mat22 *arg2 = 0 ; + b2Mat22 temp1 ; + b2Mat22 temp2 ; + b2Mat22 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Mat22 const &)*arg1,(b2Mat22 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat33 *arg1 = 0 ; + b2Vec3 *arg2 = 0 ; + b2Mat33 temp1 ; + b2Vec3 temp2 ; + b2Vec3 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Mat33 const &)*arg1,(b2Vec3 const &)*arg2); + + 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; +} + +static bool js_b2Mul22(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Mat33 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Mat33 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul22((b2Mat33 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Mul22) + +static bool js_b2Mul__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Rot *arg2 = 0 ; + b2Rot temp1 ; + b2Rot temp2 ; + b2Rot result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Rot const &)*arg1,(b2Rot const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Rot *arg2 = 0 ; + b2Rot temp1 ; + b2Rot temp2 ; + b2Rot result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Rot const &)*arg1,(b2Rot const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Rot temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Rot const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Rot *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Rot temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Rot const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Transform temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Transform const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2MulT__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Transform temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Transform const &)*arg1,(b2Vec2 const &)*arg2); + + 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; +} + +static bool js_b2Mul__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Transform *arg2 = 0 ; + b2Transform temp1 ; + b2Transform temp2 ; + b2Transform result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Mul((b2Transform const &)*arg1,(b2Transform const &)*arg2); + + 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; +} + +static bool js_b2Mul(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2Mul__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2Mul__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Mul) + +static bool js_b2MulT__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Transform *arg1 = 0 ; + b2Transform *arg2 = 0 ; + b2Transform temp1 ; + b2Transform temp2 ; + b2Transform result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2MulT((b2Transform const &)*arg1,(b2Transform const &)*arg2); + + 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; +} + +static bool js_b2MulT(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_b2MulT__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2MulT__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2MulT) + +static bool js_b2Abs__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Vec2 *arg1 = 0 ; + b2Vec2 temp1 ; + b2Vec2 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = b2Abs((b2Vec2 const &)*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; +} + +static bool js_b2Abs__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Mat22 *arg1 = 0 ; + b2Mat22 temp1 ; + b2Mat22 result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = b2Abs((b2Mat22 const &)*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; +} + +static bool js_b2Abs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_b2Abs__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_b2Abs__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2Abs) + +static bool js_b2Min(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Min((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Min) + +static bool js_b2Max(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Vec2 result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = b2Max((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Max) + +static bool js_b2Clamp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Vec2 *arg1 = 0 ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 temp1 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + b2Vec2 result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = b2Clamp((b2Vec2 const &)*arg1,(b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2Clamp) + +static bool js_b2NextPowerOfTwo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32 arg1 ; + uint32 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = b2NextPowerOfTwo(SWIG_STD_MOVE(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_FUNC(js_b2NextPowerOfTwo) + +static bool js_b2IsPowerOfTwo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32 arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)b2IsPowerOfTwo(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2IsPowerOfTwo) + +se::Class* __jsb_b2MassData_class = nullptr; +se::Object* __jsb_b2MassData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MassData) + +static bool js_MassData_mass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MassData_mass_set) + +static bool js_MassData_mass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MassData_mass_get) + +static bool js_MassData_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_MassData_center_set) + +static bool js_MassData_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_MassData_center_get) + +static bool js_MassData_I_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->I, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MassData_I_set) + +static bool js_MassData_I_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MassData *arg1 = (b2MassData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->I, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MassData_I_get) + +static bool js_new_b2MassData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2MassData *result; + result = (b2MassData *)new b2MassData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2MassData, __jsb_b2MassData_class, js_delete_b2MassData) + +static bool js_delete_b2MassData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MassData) + +template<> +bool sevalue_to_native(const se::Value &from, b2MassData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("mass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mass), ctx); + } + + + json->getProperty("center", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->center), ctx); + } + + + json->getProperty("I", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->I), ctx); + } + + + return ok; +} + + +bool js_register_b2MassData(se::Object* obj) { + auto* cls = se::Class::create("MassData", obj, nullptr, _SE(js_new_b2MassData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mass", _SE(js_MassData_mass_get), _SE(js_MassData_mass_set)); + cls->defineProperty("center", _SE(js_MassData_center_get), _SE(js_MassData_center_set)); + cls->defineProperty("I", _SE(js_MassData_I_get), _SE(js_MassData_I_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MassData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MassData_proto = cls->getProto(); + __jsb_b2MassData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Shape_class = nullptr; +se::Object* __jsb_b2Shape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Shape) + +static bool js_delete_b2Shape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Shape) + +static bool js_Shape_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2Shape::Type result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape::Type)((b2Shape const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Shape_GetType) + +static bool js_Shape_GetChildCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Shape const *)arg1)->GetChildCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Shape_GetChildCount) + +static bool js_Shape_TestPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2Transform *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Transform temp2 ; + b2Vec2 temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)((b2Shape const *)arg1)->TestPoint((b2Transform const &)*arg2,(b2Vec2 const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Shape_TestPoint) + +static bool js_Shape_RayCast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2RayCastOutput *arg2 = (b2RayCastOutput *) NULL ; + b2RayCastInput *arg3 = 0 ; + b2Transform *arg4 = 0 ; + int32 arg5 ; + b2RayCastInput temp3 ; + b2Transform temp4 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((b2Shape const *)arg1)->RayCast(arg2,(b2RayCastInput const &)*arg3,(b2Transform const &)*arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Shape_RayCast) + +static bool js_Shape_ComputeAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2AABB *arg2 = (b2AABB *) NULL ; + b2Transform *arg3 = 0 ; + int32 arg4 ; + b2Transform temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ((b2Shape const *)arg1)->ComputeAABB(arg2,(b2Transform const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Shape_ComputeAABB) + +static bool js_Shape_ComputeMass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + ((b2Shape const *)arg1)->ComputeMass(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Shape_ComputeMass) + +static bool js_Shape_m_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Shape_m_type_set) + +static bool js_Shape_m_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Shape_m_type_get) + +static bool js_Shape_m_radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_radius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Shape_m_radius_set) + +static bool js_Shape_m_radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Shape *arg1 = (b2Shape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_radius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Shape_m_radius_get) + +bool js_register_b2Shape(se::Object* obj) { + auto* cls = se::Class::create("Shape", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_type", _SE(js_Shape_m_type_get), _SE(js_Shape_m_type_set)); + cls->defineProperty("m_radius", _SE(js_Shape_m_radius_get), _SE(js_Shape_m_radius_set)); + + cls->defineFunction("GetType", _SE(js_Shape_GetType)); + cls->defineFunction("GetChildCount", _SE(js_Shape_GetChildCount)); + cls->defineFunction("TestPoint", _SE(js_Shape_TestPoint)); + cls->defineFunction("RayCast", _SE(js_Shape_RayCast)); + cls->defineFunction("ComputeAABB", _SE(js_Shape_ComputeAABB)); + cls->defineFunction("ComputeMass", _SE(js_Shape_ComputeMass)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Shape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Shape_proto = cls->getProto(); + __jsb_b2Shape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Color_class = nullptr; +se::Object* __jsb_b2Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Color) + +static bool js_new_b2Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + b2Color *result; + result = (b2Color *)new b2Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + b2Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Color *)new b2Color(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Color__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + b2Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Color *)new b2Color(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_b2Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_b2Color__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_b2Color__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_b2Color__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Color"); + return false; +} +SE_BIND_CTOR(js_new_b2Color, __jsb_b2Color_class, js_delete_b2Color) + +static bool js_Color_Set__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Color *arg1 = (b2Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_Color_Set__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Color *arg1 = (b2Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->Set(arg2,arg3,arg4); + + + return true; +} + +static bool js_Color_Set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_Color_Set__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_Color_Set__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Color_Set) + +static bool js_Color_r_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->r, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_r_set) + +static bool js_Color_r_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->r, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_r_get) + +static bool js_Color_g_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->g, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_g_set) + +static bool js_Color_g_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->g, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_g_get) + +static bool js_Color_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_b_set) + +static bool js_Color_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_b_get) + +static bool js_Color_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Color_a_set) + +static bool js_Color_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Color *arg1 = (b2Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Color_a_get) + +static bool js_delete_b2Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Color) + +template<> +bool sevalue_to_native(const se::Value &from, b2Color * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("r", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->r), ctx); + } + + + json->getProperty("g", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->g), ctx); + } + + + json->getProperty("b", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->b), ctx); + } + + + json->getProperty("a", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a), ctx); + } + + + return ok; +} + + +bool js_register_b2Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_b2Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("r", _SE(js_Color_r_get), _SE(js_Color_r_set)); + cls->defineProperty("g", _SE(js_Color_g_get), _SE(js_Color_g_set)); + cls->defineProperty("b", _SE(js_Color_b_get), _SE(js_Color_b_set)); + cls->defineProperty("a", _SE(js_Color_a_get), _SE(js_Color_a_set)); + + cls->defineFunction("Set", _SE(js_Color_Set)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Color_proto = cls->getProto(); + __jsb_b2Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactFeature_class = nullptr; +se::Object* __jsb_b2ContactFeature_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactFeature) + +static bool js_ContactFeature_indexA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_indexA_set) + +static bool js_ContactFeature_indexA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_indexA_get) + +static bool js_ContactFeature_indexB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_indexB_set) + +static bool js_ContactFeature_indexB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_indexB_get) + +static bool js_ContactFeature_typeA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->typeA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_typeA_set) + +static bool js_ContactFeature_typeA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->typeA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->typeA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_typeA_get) + +static bool js_ContactFeature_typeB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->typeB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactFeature_typeB_set) + +static bool js_ContactFeature_typeB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactFeature *arg1 = (b2ContactFeature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->typeB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->typeB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactFeature_typeB_get) + +static bool js_new_b2ContactFeature(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactFeature *result; + result = (b2ContactFeature *)new b2ContactFeature(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactFeature, __jsb_b2ContactFeature_class, js_delete_b2ContactFeature) + +static bool js_delete_b2ContactFeature(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactFeature) + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactFeature * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("indexA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexA), ctx); + } + + + json->getProperty("indexB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexB), ctx); + } + + + json->getProperty("typeA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->typeA), ctx); + } + + + json->getProperty("typeB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->typeB), ctx); + } + + + return ok; +} + + +bool js_register_b2ContactFeature(se::Object* obj) { + auto* cls = se::Class::create("ContactFeature", obj, nullptr, _SE(js_new_b2ContactFeature)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("indexA", _SE(js_ContactFeature_indexA_get), _SE(js_ContactFeature_indexA_set)); + cls->defineProperty("indexB", _SE(js_ContactFeature_indexB_get), _SE(js_ContactFeature_indexB_set)); + cls->defineProperty("typeA", _SE(js_ContactFeature_typeA_get), _SE(js_ContactFeature_typeA_set)); + cls->defineProperty("typeB", _SE(js_ContactFeature_typeB_get), _SE(js_ContactFeature_typeB_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactFeature)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactFeature_proto = cls->getProto(); + __jsb_b2ContactFeature_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactID_class = nullptr; +se::Object* __jsb_b2ContactID_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactID) + +static bool js_ContactID_cf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cf, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactID_cf_set) + +static bool js_ContactID_cf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cf, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cf, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactID_cf_get) + +static bool js_ContactID_key_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->key, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactID_key_set) + +static bool js_ContactID_key_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactID *arg1 = (b2ContactID *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->key, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->key, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactID_key_get) + +static bool js_new_b2ContactID(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactID *result; + result = (b2ContactID *)new b2ContactID(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactID, __jsb_b2ContactID_class, js_delete_b2ContactID) + +static bool js_delete_b2ContactID(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactID) + +bool js_register_b2ContactID(se::Object* obj) { + auto* cls = se::Class::create("ContactID", obj, nullptr, _SE(js_new_b2ContactID)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("cf", _SE(js_ContactID_cf_get), _SE(js_ContactID_cf_set)); + cls->defineProperty("key", _SE(js_ContactID_key_get), _SE(js_ContactID_key_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactID)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactID_proto = cls->getProto(); + __jsb_b2ContactID_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ManifoldPoint_class = nullptr; +se::Object* __jsb_b2ManifoldPoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ManifoldPoint) + +static bool js_ManifoldPoint_localPoint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localPoint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_localPoint_set) + +static bool js_ManifoldPoint_localPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localPoint, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localPoint, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_localPoint_get) + +static bool js_ManifoldPoint_normalImpulse_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normalImpulse, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_normalImpulse_set) + +static bool js_ManifoldPoint_normalImpulse_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normalImpulse, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_normalImpulse_get) + +static bool js_ManifoldPoint_tangentImpulse_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tangentImpulse, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_tangentImpulse_set) + +static bool js_ManifoldPoint_tangentImpulse_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tangentImpulse, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_tangentImpulse_get) + +static bool js_ManifoldPoint_id_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->id, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ManifoldPoint_id_set) + +static bool js_ManifoldPoint_id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ManifoldPoint *arg1 = (b2ManifoldPoint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->id, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->id, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ManifoldPoint_id_get) + +static bool js_new_b2ManifoldPoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ManifoldPoint *result; + result = (b2ManifoldPoint *)new b2ManifoldPoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ManifoldPoint, __jsb_b2ManifoldPoint_class, js_delete_b2ManifoldPoint) + +static bool js_delete_b2ManifoldPoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ManifoldPoint) + +template<> +bool sevalue_to_native(const se::Value &from, b2ManifoldPoint * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localPoint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localPoint), ctx); + } + + + json->getProperty("normalImpulse", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normalImpulse), ctx); + } + + + json->getProperty("tangentImpulse", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tangentImpulse), ctx); + } + + + json->getProperty("id", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->id), ctx); + } + + + return ok; +} + + +bool js_register_b2ManifoldPoint(se::Object* obj) { + auto* cls = se::Class::create("ManifoldPoint", obj, nullptr, _SE(js_new_b2ManifoldPoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localPoint", _SE(js_ManifoldPoint_localPoint_get), _SE(js_ManifoldPoint_localPoint_set)); + cls->defineProperty("normalImpulse", _SE(js_ManifoldPoint_normalImpulse_get), _SE(js_ManifoldPoint_normalImpulse_set)); + cls->defineProperty("tangentImpulse", _SE(js_ManifoldPoint_tangentImpulse_get), _SE(js_ManifoldPoint_tangentImpulse_set)); + cls->defineProperty("id", _SE(js_ManifoldPoint_id_get), _SE(js_ManifoldPoint_id_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ManifoldPoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ManifoldPoint_proto = cls->getProto(); + __jsb_b2ManifoldPoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Manifold_class = nullptr; +se::Object* __jsb_b2Manifold_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Manifold) + +static bool js_Manifold_localNormal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localNormal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_localNormal_set) + +static bool js_Manifold_localNormal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localNormal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localNormal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_localNormal_get) + +static bool js_Manifold_localPoint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localPoint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_localPoint_set) + +static bool js_Manifold_localPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localPoint, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localPoint, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_localPoint_get) + +static bool js_Manifold_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_type_set) + +static bool js_Manifold_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_type_get) + +static bool js_Manifold_pointCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pointCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Manifold_pointCount_set) + +static bool js_Manifold_pointCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Manifold *arg1 = (b2Manifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pointCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pointCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Manifold_pointCount_get) + +static bool js_new_b2Manifold(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Manifold *result; + result = (b2Manifold *)new b2Manifold(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Manifold, __jsb_b2Manifold_class, js_delete_b2Manifold) + +static bool js_delete_b2Manifold(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Manifold) + +template<> +bool sevalue_to_native(const se::Value &from, b2Manifold * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localNormal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localNormal), ctx); + } + + + json->getProperty("localPoint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localPoint), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("pointCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pointCount), ctx); + } + + + return ok; +} + + +bool js_register_b2Manifold(se::Object* obj) { + auto* cls = se::Class::create("Manifold", obj, nullptr, _SE(js_new_b2Manifold)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localNormal", _SE(js_Manifold_localNormal_get), _SE(js_Manifold_localNormal_set)); + cls->defineProperty("localPoint", _SE(js_Manifold_localPoint_get), _SE(js_Manifold_localPoint_set)); + cls->defineProperty("type", _SE(js_Manifold_type_get), _SE(js_Manifold_type_set)); + cls->defineProperty("pointCount", _SE(js_Manifold_pointCount_get), _SE(js_Manifold_pointCount_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Manifold)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Manifold_proto = cls->getProto(); + __jsb_b2Manifold_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WorldManifold_class = nullptr; +se::Object* __jsb_b2WorldManifold_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WorldManifold) + +static bool js_WorldManifold_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WorldManifold *arg1 = (b2WorldManifold *) NULL ; + b2Manifold *arg2 = (b2Manifold *) NULL ; + b2Transform *arg3 = 0 ; + float arg4 ; + b2Transform *arg5 = 0 ; + float arg6 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Initialize((b2Manifold const *)arg2,(b2Transform const &)*arg3,arg4,(b2Transform const &)*arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_WorldManifold_Initialize) + +static bool js_WorldManifold_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WorldManifold *arg1 = (b2WorldManifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WorldManifold_normal_set) + +static bool js_WorldManifold_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WorldManifold *arg1 = (b2WorldManifold *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WorldManifold_normal_get) + +static bool js_new_b2WorldManifold(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2WorldManifold *result; + result = (b2WorldManifold *)new b2WorldManifold(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2WorldManifold, __jsb_b2WorldManifold_class, js_delete_b2WorldManifold) + +static bool js_delete_b2WorldManifold(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WorldManifold) + +template<> +bool sevalue_to_native(const se::Value &from, b2WorldManifold * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("normal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normal), ctx); + } + + + return ok; +} + + +bool js_register_b2WorldManifold(se::Object* obj) { + auto* cls = se::Class::create("WorldManifold", obj, nullptr, _SE(js_new_b2WorldManifold)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("normal", _SE(js_WorldManifold_normal_get), _SE(js_WorldManifold_normal_set)); + + cls->defineFunction("Initialize", _SE(js_WorldManifold_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WorldManifold)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WorldManifold_proto = cls->getProto(); + __jsb_b2WorldManifold_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ClipVertex_class = nullptr; +se::Object* __jsb_b2ClipVertex_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ClipVertex) + +static bool js_ClipVertex_v_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ClipVertex_v_set) + +static bool js_ClipVertex_v_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->v, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ClipVertex_v_get) + +static bool js_ClipVertex_id_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->id, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ClipVertex_id_set) + +static bool js_ClipVertex_id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ClipVertex *arg1 = (b2ClipVertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->id, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->id, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ClipVertex_id_get) + +static bool js_new_b2ClipVertex(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ClipVertex *result; + result = (b2ClipVertex *)new b2ClipVertex(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ClipVertex, __jsb_b2ClipVertex_class, js_delete_b2ClipVertex) + +static bool js_delete_b2ClipVertex(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ClipVertex) + +template<> +bool sevalue_to_native(const se::Value &from, b2ClipVertex * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("v", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->v), ctx); + } + + + json->getProperty("id", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->id), ctx); + } + + + return ok; +} + + +bool js_register_b2ClipVertex(se::Object* obj) { + auto* cls = se::Class::create("ClipVertex", obj, nullptr, _SE(js_new_b2ClipVertex)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("v", _SE(js_ClipVertex_v_get), _SE(js_ClipVertex_v_set)); + cls->defineProperty("id", _SE(js_ClipVertex_id_get), _SE(js_ClipVertex_id_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ClipVertex)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ClipVertex_proto = cls->getProto(); + __jsb_b2ClipVertex_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RayCastInput_class = nullptr; +se::Object* __jsb_b2RayCastInput_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RayCastInput) + +static bool js_RayCastInput_p1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->p1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RayCastInput_p1_set) + +static bool js_RayCastInput_p1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->p1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->p1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RayCastInput_p1_get) + +static bool js_RayCastInput_p2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->p2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RayCastInput_p2_set) + +static bool js_RayCastInput_p2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->p2, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->p2, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RayCastInput_p2_get) + +static bool js_RayCastInput_maxFraction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxFraction, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RayCastInput_maxFraction_set) + +static bool js_RayCastInput_maxFraction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastInput *arg1 = (b2RayCastInput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxFraction, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RayCastInput_maxFraction_get) + +static bool js_new_b2RayCastInput(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RayCastInput *result; + result = (b2RayCastInput *)new b2RayCastInput(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RayCastInput, __jsb_b2RayCastInput_class, js_delete_b2RayCastInput) + +static bool js_delete_b2RayCastInput(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RayCastInput) + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastInput * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("p1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->p1), ctx); + } + + + json->getProperty("p2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->p2), ctx); + } + + + json->getProperty("maxFraction", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxFraction), ctx); + } + + + return ok; +} + + +bool js_register_b2RayCastInput(se::Object* obj) { + auto* cls = se::Class::create("RayCastInput", obj, nullptr, _SE(js_new_b2RayCastInput)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("p1", _SE(js_RayCastInput_p1_get), _SE(js_RayCastInput_p1_set)); + cls->defineProperty("p2", _SE(js_RayCastInput_p2_get), _SE(js_RayCastInput_p2_set)); + cls->defineProperty("maxFraction", _SE(js_RayCastInput_maxFraction_get), _SE(js_RayCastInput_maxFraction_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RayCastInput)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RayCastInput_proto = cls->getProto(); + __jsb_b2RayCastInput_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RayCastOutput_class = nullptr; +se::Object* __jsb_b2RayCastOutput_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RayCastOutput) + +static bool js_RayCastOutput_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RayCastOutput_normal_set) + +static bool js_RayCastOutput_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RayCastOutput_normal_get) + +static bool js_RayCastOutput_fraction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fraction, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RayCastOutput_fraction_set) + +static bool js_RayCastOutput_fraction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RayCastOutput *arg1 = (b2RayCastOutput *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fraction, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RayCastOutput_fraction_get) + +static bool js_new_b2RayCastOutput(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RayCastOutput *result; + result = (b2RayCastOutput *)new b2RayCastOutput(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RayCastOutput, __jsb_b2RayCastOutput_class, js_delete_b2RayCastOutput) + +static bool js_delete_b2RayCastOutput(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RayCastOutput) + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastOutput * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("normal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normal), ctx); + } + + + json->getProperty("fraction", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->fraction), ctx); + } + + + return ok; +} + + +bool js_register_b2RayCastOutput(se::Object* obj) { + auto* cls = se::Class::create("RayCastOutput", obj, nullptr, _SE(js_new_b2RayCastOutput)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("normal", _SE(js_RayCastOutput_normal_get), _SE(js_RayCastOutput_normal_set)); + cls->defineProperty("fraction", _SE(js_RayCastOutput_fraction_get), _SE(js_RayCastOutput_fraction_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RayCastOutput)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RayCastOutput_proto = cls->getProto(); + __jsb_b2RayCastOutput_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2AABB_class = nullptr; +se::Object* __jsb_b2AABB_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2AABB) + +static bool js_AABB_IsValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2AABB const *)arg1)->IsValid(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_IsValid) + +static bool js_AABB_GetCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2AABB const *)arg1)->GetCenter(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_AABB_GetCenter) + +static bool js_AABB_GetExtents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2AABB const *)arg1)->GetExtents(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_AABB_GetExtents) + +static bool js_AABB_GetPerimeter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2AABB const *)arg1)->GetPerimeter(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_GetPerimeter) + +static bool js_AABB_Combine__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2AABB *arg2 = 0 ; + b2AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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)->Combine((b2AABB const &)*arg2); + + + return true; +} + +static bool js_AABB_Combine__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2AABB *arg2 = 0 ; + b2AABB *arg3 = 0 ; + b2AABB temp2 ; + b2AABB temp3 ; + + arg1 = SE_THIS_OBJECT(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)->Combine((b2AABB const &)*arg2,(b2AABB const &)*arg3); + + + return true; +} + +static bool js_AABB_Combine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_AABB_Combine__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_AABB_Combine__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_AABB_Combine) + +static bool js_AABB_Contains(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2AABB *arg2 = 0 ; + b2AABB 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(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)((b2AABB const *)arg1)->Contains((b2AABB const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_Contains) + +static bool js_AABB_RayCast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + b2RayCastOutput *arg2 = (b2RayCastOutput *) NULL ; + b2RayCastInput *arg3 = 0 ; + b2RayCastInput temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((b2AABB const *)arg1)->RayCast(arg2,(b2RayCastInput const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_AABB_RayCast) + +static bool js_AABB_lowerBound_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lowerBound, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_AABB_lowerBound_set) + +static bool js_AABB_lowerBound_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lowerBound, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->lowerBound, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_AABB_lowerBound_get) + +static bool js_AABB_upperBound_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->upperBound, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_AABB_upperBound_set) + +static bool js_AABB_upperBound_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2AABB *arg1 = (b2AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->upperBound, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->upperBound, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_AABB_upperBound_get) + +static bool js_new_b2AABB(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2AABB *result; + result = (b2AABB *)new b2AABB(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2AABB, __jsb_b2AABB_class, js_delete_b2AABB) + +static bool js_delete_b2AABB(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2AABB) + +template<> +bool sevalue_to_native(const se::Value &from, b2AABB * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("lowerBound", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lowerBound), ctx); + } + + + json->getProperty("upperBound", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->upperBound), ctx); + } + + + return ok; +} + + +bool js_register_b2AABB(se::Object* obj) { + auto* cls = se::Class::create("AABB", obj, nullptr, _SE(js_new_b2AABB)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("lowerBound", _SE(js_AABB_lowerBound_get), _SE(js_AABB_lowerBound_set)); + cls->defineProperty("upperBound", _SE(js_AABB_upperBound_get), _SE(js_AABB_upperBound_set)); + + cls->defineFunction("IsValid", _SE(js_AABB_IsValid)); + cls->defineFunction("GetCenter", _SE(js_AABB_GetCenter)); + cls->defineFunction("GetExtents", _SE(js_AABB_GetExtents)); + cls->defineFunction("GetPerimeter", _SE(js_AABB_GetPerimeter)); + cls->defineFunction("Combine", _SE(js_AABB_Combine)); + cls->defineFunction("Contains", _SE(js_AABB_Contains)); + cls->defineFunction("RayCast", _SE(js_AABB_RayCast)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2AABB)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2AABB_proto = cls->getProto(); + __jsb_b2AABB_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_b2CollideCircles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2CircleShape *arg2 = (b2CircleShape *) NULL ; + b2Transform *arg3 = 0 ; + b2CircleShape *arg4 = (b2CircleShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollideCircles(arg1,(b2CircleShape const *)arg2,(b2Transform const &)*arg3,(b2CircleShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollideCircles) + +static bool js_b2CollidePolygonAndCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2PolygonShape *arg2 = (b2PolygonShape *) NULL ; + b2Transform *arg3 = 0 ; + b2CircleShape *arg4 = (b2CircleShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollidePolygonAndCircle(arg1,(b2PolygonShape const *)arg2,(b2Transform const &)*arg3,(b2CircleShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollidePolygonAndCircle) + +static bool js_b2CollidePolygons(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2PolygonShape *arg2 = (b2PolygonShape *) NULL ; + b2Transform *arg3 = 0 ; + b2PolygonShape *arg4 = (b2PolygonShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollidePolygons(arg1,(b2PolygonShape const *)arg2,(b2Transform const &)*arg3,(b2PolygonShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollidePolygons) + +static bool js_b2CollideEdgeAndCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2EdgeShape *arg2 = (b2EdgeShape *) NULL ; + b2Transform *arg3 = 0 ; + b2CircleShape *arg4 = (b2CircleShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollideEdgeAndCircle(arg1,(b2EdgeShape const *)arg2,(b2Transform const &)*arg3,(b2CircleShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollideEdgeAndCircle) + +static bool js_b2CollideEdgeAndPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Manifold *arg1 = (b2Manifold *) NULL ; + b2EdgeShape *arg2 = (b2EdgeShape *) NULL ; + b2Transform *arg3 = 0 ; + b2PolygonShape *arg4 = (b2PolygonShape *) NULL ; + b2Transform *arg5 = 0 ; + b2Transform temp3 ; + b2Transform temp5 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + b2CollideEdgeAndPolygon(arg1,(b2EdgeShape const *)arg2,(b2Transform const &)*arg3,(b2PolygonShape const *)arg4,(b2Transform const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_b2CollideEdgeAndPolygon) + +static bool js_b2ClipSegmentToLine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ClipVertex *arg1 ; + b2ClipVertex *arg2 ; + b2Vec2 *arg3 = 0 ; + float arg4 ; + int32 arg5 ; + b2Vec2 temp3 ; + int32 result; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = b2ClipSegmentToLine(arg1,(b2ClipVertex const (*))arg2,(b2Vec2 const &)*arg3,arg4,SWIG_STD_MOVE(arg5)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_b2ClipSegmentToLine) + +static bool js_b2TestOverlap__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Shape *arg1 = (b2Shape *) NULL ; + int32 arg2 ; + b2Shape *arg3 = (b2Shape *) NULL ; + int32 arg4 ; + b2Transform *arg5 = 0 ; + b2Transform *arg6 = 0 ; + b2Transform temp5 ; + b2Transform temp6 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[5], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (bool)b2TestOverlap((b2Shape const *)arg1,SWIG_STD_MOVE(arg2),(b2Shape const *)arg3,SWIG_STD_MOVE(arg4),(b2Transform const &)*arg5,(b2Transform const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2TestOverlap__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2AABB *arg1 = 0 ; + b2AABB *arg2 = 0 ; + b2AABB temp1 ; + b2AABB temp2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)b2TestOverlap((b2AABB const &)*arg1,(b2AABB const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_b2TestOverlap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_b2TestOverlap__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_b2TestOverlap__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_b2TestOverlap) + +se::Class* __jsb_b2Jacobian_class = nullptr; +se::Object* __jsb_b2Jacobian_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Jacobian) + +static bool js_Jacobian_linear_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linear, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Jacobian_linear_set) + +static bool js_Jacobian_linear_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linear, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linear, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Jacobian_linear_get) + +static bool js_Jacobian_angularA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Jacobian_angularA_set) + +static bool js_Jacobian_angularA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularA, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Jacobian_angularA_get) + +static bool js_Jacobian_angularB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Jacobian_angularB_set) + +static bool js_Jacobian_angularB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Jacobian *arg1 = (b2Jacobian *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularB, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Jacobian_angularB_get) + +static bool js_new_b2Jacobian(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Jacobian *result; + result = (b2Jacobian *)new b2Jacobian(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Jacobian, __jsb_b2Jacobian_class, js_delete_b2Jacobian) + +static bool js_delete_b2Jacobian(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Jacobian) + +template<> +bool sevalue_to_native(const se::Value &from, b2Jacobian * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("linear", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linear), ctx); + } + + + json->getProperty("angularA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularA), ctx); + } + + + json->getProperty("angularB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularB), ctx); + } + + + return ok; +} + + +bool js_register_b2Jacobian(se::Object* obj) { + auto* cls = se::Class::create("Jacobian", obj, nullptr, _SE(js_new_b2Jacobian)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("linear", _SE(js_Jacobian_linear_get), _SE(js_Jacobian_linear_set)); + cls->defineProperty("angularA", _SE(js_Jacobian_angularA_get), _SE(js_Jacobian_angularA_set)); + cls->defineProperty("angularB", _SE(js_Jacobian_angularB_get), _SE(js_Jacobian_angularB_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Jacobian)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Jacobian_proto = cls->getProto(); + __jsb_b2Jacobian_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2JointEdge_class = nullptr; +se::Object* __jsb_b2JointEdge_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2JointEdge) + +static bool js_JointEdge_other_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->other, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_other_set) + +static bool js_JointEdge_other_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->other, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->other, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_other_get) + +static bool js_JointEdge_joint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->joint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_joint_set) + +static bool js_JointEdge_joint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->joint, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->joint, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_joint_get) + +static bool js_JointEdge_prev_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prev, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_prev_set) + +static bool js_JointEdge_prev_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prev, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prev, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_prev_get) + +static bool js_JointEdge_next_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->next, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointEdge_next_set) + +static bool js_JointEdge_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointEdge *arg1 = (b2JointEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->next, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->next, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointEdge_next_get) + +static bool js_new_b2JointEdge(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2JointEdge *result; + result = (b2JointEdge *)new b2JointEdge(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2JointEdge, __jsb_b2JointEdge_class, js_delete_b2JointEdge) + +static bool js_delete_b2JointEdge(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2JointEdge) + +template<> +bool sevalue_to_native(const se::Value &from, b2JointEdge * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("other", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->other), ctx); + } + + + json->getProperty("joint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->joint), ctx); + } + + + json->getProperty("prev", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prev), ctx); + } + + + json->getProperty("next", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->next), ctx); + } + + + return ok; +} + + +bool js_register_b2JointEdge(se::Object* obj) { + auto* cls = se::Class::create("JointEdge", obj, nullptr, _SE(js_new_b2JointEdge)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("other", _SE(js_JointEdge_other_get), _SE(js_JointEdge_other_set)); + cls->defineProperty("joint", _SE(js_JointEdge_joint_get), _SE(js_JointEdge_joint_set)); + cls->defineProperty("prev", _SE(js_JointEdge_prev_get), _SE(js_JointEdge_prev_set)); + cls->defineProperty("next", _SE(js_JointEdge_next_get), _SE(js_JointEdge_next_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2JointEdge)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2JointEdge_proto = cls->getProto(); + __jsb_b2JointEdge_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2JointDef_class = nullptr; +se::Object* __jsb_b2JointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2JointDef) + +static bool js_new_b2JointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2JointDef *result; + result = (b2JointDef *)new b2JointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2JointDef, __jsb_b2JointDef_class, js_delete_b2JointDef) + +static bool js_JointDef_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_type_set) + +static bool js_JointDef_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_type_get) + +static bool js_JointDef_bodyA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bodyA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_bodyA_set) + +static bool js_JointDef_bodyA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bodyA, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bodyA, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_bodyA_get) + +static bool js_JointDef_bodyB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bodyB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_bodyB_set) + +static bool js_JointDef_bodyB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bodyB, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bodyB, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_bodyB_get) + +static bool js_JointDef_collideConnected_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->collideConnected); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_JointDef_collideConnected_set) + +static bool js_JointDef_collideConnected_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2JointDef *arg1 = (b2JointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->collideConnected, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_JointDef_collideConnected_get) + +static bool js_delete_b2JointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2JointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2JointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("bodyA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bodyA), ctx); + } + + + json->getProperty("bodyB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bodyB), ctx); + } + + + json->getProperty("collideConnected", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->collideConnected), ctx); + } + + + return ok; +} + + +bool js_register_b2JointDef(se::Object* obj) { + auto* cls = se::Class::create("JointDef", obj, nullptr, _SE(js_new_b2JointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_JointDef_type_get), _SE(js_JointDef_type_set)); + cls->defineProperty("bodyA", _SE(js_JointDef_bodyA_get), _SE(js_JointDef_bodyA_set)); + cls->defineProperty("bodyB", _SE(js_JointDef_bodyB_get), _SE(js_JointDef_bodyB_set)); + cls->defineProperty("collideConnected", _SE(js_JointDef_collideConnected_get), _SE(js_JointDef_collideConnected_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2JointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2JointDef_proto = cls->getProto(); + __jsb_b2JointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Joint_class = nullptr; +se::Object* __jsb_b2Joint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Joint) + +static bool js_Joint_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2JointType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2JointType)((b2Joint const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetType) + +static bool js_Joint_GetBodyA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Body *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(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBodyA(); + + 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_Joint_GetBodyA) + +static bool js_Joint_GetBodyB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Body *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(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBodyB(); + + 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_Joint_GetBodyB) + +static bool js_Joint_GetAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Joint const *)arg1)->GetAnchorA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetAnchorA) + +static bool js_Joint_GetAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Joint const *)arg1)->GetAnchorB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetAnchorB) + +static bool js_Joint_GetReactionForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + float arg2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((b2Joint const *)arg1)->GetReactionForce(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Joint_GetReactionForce) + +static bool js_Joint_GetReactionTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2Joint const *)arg1)->GetReactionTorque(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Joint_GetReactionTorque) + +static bool js_Joint_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetNext(); + + 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_Joint_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)((b2Joint const *)arg1)->GetNext(); + + 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_Joint_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Joint_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Joint_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Joint_GetNext) + +static bool js_Joint_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((b2Joint const *)arg1)->GetUserData(); + + 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_Joint_GetUserData) + +static bool js_Joint_SetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetUserData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Joint_SetUserData) + +static bool js_Joint_IsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Joint const *)arg1)->IsEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Joint_IsEnabled) + +static bool js_Joint_GetCollideConnected(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Joint const *)arg1)->GetCollideConnected(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Joint_GetCollideConnected) + +static bool js_Joint_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Dump(); + + + return true; +} +SE_BIND_FUNC(js_Joint_Dump) + +static bool js_Joint_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Joint *arg1 = (b2Joint *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Joint_ShiftOrigin) + +bool js_register_b2Joint(se::Object* obj) { + auto* cls = se::Class::create("Joint", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetType", _SE(js_Joint_GetType)); + cls->defineFunction("GetBodyA", _SE(js_Joint_GetBodyA)); + cls->defineFunction("GetBodyB", _SE(js_Joint_GetBodyB)); + cls->defineFunction("GetAnchorA", _SE(js_Joint_GetAnchorA)); + cls->defineFunction("GetAnchorB", _SE(js_Joint_GetAnchorB)); + cls->defineFunction("GetReactionForce", _SE(js_Joint_GetReactionForce)); + cls->defineFunction("GetReactionTorque", _SE(js_Joint_GetReactionTorque)); + cls->defineFunction("GetNext", _SE(js_Joint_GetNext)); + cls->defineFunction("GetUserData", _SE(js_Joint_GetUserData)); + cls->defineFunction("SetUserData", _SE(js_Joint_SetUserData)); + cls->defineFunction("IsEnabled", _SE(js_Joint_IsEnabled)); + cls->defineFunction("GetCollideConnected", _SE(js_Joint_GetCollideConnected)); + cls->defineFunction("Dump", _SE(js_Joint_Dump)); + cls->defineFunction("ShiftOrigin", _SE(js_Joint_ShiftOrigin)); + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Joint_proto = cls->getProto(); + __jsb_b2Joint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ChainShape_class = nullptr; +se::Object* __jsb_b2ChainShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ChainShape) + +static bool js_new_b2ChainShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ChainShape *result; + result = (b2ChainShape *)new b2ChainShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ChainShape, __jsb_b2ChainShape_class, js_delete_b2ChainShape) + +static bool js_delete_b2ChainShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ChainShape) + +static bool js_ChainShape_Clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Clear(); + + + return true; +} +SE_BIND_FUNC(js_ChainShape_Clear) + +static bool js_ChainShape_GetChildEdge(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + b2EdgeShape *arg2 = (b2EdgeShape *) NULL ; + int32 arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + + ((b2ChainShape const *)arg1)->GetChildEdge(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_ChainShape_GetChildEdge) + +static bool js_ChainShape_m_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ChainShape_m_count_set) + +static bool js_ChainShape_m_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_count, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_count, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ChainShape_m_count_get) + +static bool js_ChainShape_m_prevVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_prevVertex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ChainShape_m_prevVertex_set) + +static bool js_ChainShape_m_prevVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_prevVertex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_prevVertex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ChainShape_m_prevVertex_get) + +static bool js_ChainShape_m_nextVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_nextVertex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ChainShape_m_nextVertex_set) + +static bool js_ChainShape_m_nextVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ChainShape *arg1 = (b2ChainShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_nextVertex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_nextVertex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ChainShape_m_nextVertex_get) + +bool js_register_b2ChainShape(se::Object* obj) { + auto* cls = se::Class::create("ChainShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2ChainShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_count", _SE(js_ChainShape_m_count_get), _SE(js_ChainShape_m_count_set)); + cls->defineProperty("m_prevVertex", _SE(js_ChainShape_m_prevVertex_get), _SE(js_ChainShape_m_prevVertex_set)); + cls->defineProperty("m_nextVertex", _SE(js_ChainShape_m_nextVertex_get), _SE(js_ChainShape_m_nextVertex_set)); + + cls->defineFunction("Clear", _SE(js_ChainShape_Clear)); + cls->defineFunction("GetChildEdge", _SE(js_ChainShape_GetChildEdge)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ChainShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ChainShape_proto = cls->getProto(); + __jsb_b2ChainShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2CircleShape_class = nullptr; +se::Object* __jsb_b2CircleShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2CircleShape) + +static bool js_new_b2CircleShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2CircleShape *result; + result = (b2CircleShape *)new b2CircleShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2CircleShape, __jsb_b2CircleShape_class, js_delete_b2CircleShape) + +static bool js_CircleShape_m_p_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2CircleShape *arg1 = (b2CircleShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_p, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_CircleShape_m_p_set) + +static bool js_CircleShape_m_p_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2CircleShape *arg1 = (b2CircleShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_p, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_p, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_CircleShape_m_p_get) + +static bool js_delete_b2CircleShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2CircleShape) + +bool js_register_b2CircleShape(se::Object* obj) { + auto* cls = se::Class::create("CircleShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2CircleShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_p", _SE(js_CircleShape_m_p_get), _SE(js_CircleShape_m_p_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2CircleShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2CircleShape_proto = cls->getProto(); + __jsb_b2CircleShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2EdgeShape_class = nullptr; +se::Object* __jsb_b2EdgeShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2EdgeShape) + +static bool js_new_b2EdgeShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2EdgeShape *result; + result = (b2EdgeShape *)new b2EdgeShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2EdgeShape, __jsb_b2EdgeShape_class, js_delete_b2EdgeShape) + +static bool js_EdgeShape_SetOneSided(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->SetOneSided((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_EdgeShape_SetOneSided) + +static bool js_EdgeShape_SetTwoSided(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetTwoSided((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_EdgeShape_SetTwoSided) + +static bool js_EdgeShape_m_vertex1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex1_set) + +static bool js_EdgeShape_m_vertex1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex1_get) + +static bool js_EdgeShape_m_vertex2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex2_set) + +static bool js_EdgeShape_m_vertex2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex2, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex2, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex2_get) + +static bool js_EdgeShape_m_vertex0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex0_set) + +static bool js_EdgeShape_m_vertex0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex0, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex0, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex0_get) + +static bool js_EdgeShape_m_vertex3_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_vertex3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_vertex3_set) + +static bool js_EdgeShape_m_vertex3_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_vertex3, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_vertex3, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_vertex3_get) + +static bool js_EdgeShape_m_oneSided_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_oneSided); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_EdgeShape_m_oneSided_set) + +static bool js_EdgeShape_m_oneSided_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2EdgeShape *arg1 = (b2EdgeShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_oneSided, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_EdgeShape_m_oneSided_get) + +static bool js_delete_b2EdgeShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2EdgeShape) + +bool js_register_b2EdgeShape(se::Object* obj) { + auto* cls = se::Class::create("EdgeShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2EdgeShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_vertex1", _SE(js_EdgeShape_m_vertex1_get), _SE(js_EdgeShape_m_vertex1_set)); + cls->defineProperty("m_vertex2", _SE(js_EdgeShape_m_vertex2_get), _SE(js_EdgeShape_m_vertex2_set)); + cls->defineProperty("m_vertex0", _SE(js_EdgeShape_m_vertex0_get), _SE(js_EdgeShape_m_vertex0_set)); + cls->defineProperty("m_vertex3", _SE(js_EdgeShape_m_vertex3_get), _SE(js_EdgeShape_m_vertex3_set)); + cls->defineProperty("m_oneSided", _SE(js_EdgeShape_m_oneSided_get), _SE(js_EdgeShape_m_oneSided_set)); + + cls->defineFunction("SetOneSided", _SE(js_EdgeShape_SetOneSided)); + cls->defineFunction("SetTwoSided", _SE(js_EdgeShape_SetTwoSided)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2EdgeShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2EdgeShape_proto = cls->getProto(); + __jsb_b2EdgeShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PolygonShape_class = nullptr; +se::Object* __jsb_b2PolygonShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PolygonShape) + +static bool js_new_b2PolygonShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2PolygonShape *result; + result = (b2PolygonShape *)new b2PolygonShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2PolygonShape, __jsb_b2PolygonShape_class, js_delete_b2PolygonShape) + +static bool js_PolygonShape_SetAsBox__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + float arg2 ; + float arg3 ; + + arg1 = SE_THIS_OBJECT(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)->SetAsBox(arg2,arg3); + + + return true; +} + +static bool js_PolygonShape_SetAsBox__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + float arg2 ; + float arg3 ; + b2Vec2 *arg4 = 0 ; + float arg5 ; + b2Vec2 temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAsBox(arg2,arg3,(b2Vec2 const &)*arg4,arg5); + + + return true; +} + +static bool js_PolygonShape_SetAsBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_PolygonShape_SetAsBox__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_PolygonShape_SetAsBox__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_PolygonShape_SetAsBox) + +static bool js_PolygonShape_Validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PolygonShape *arg1 = (b2PolygonShape *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2PolygonShape const *)arg1)->Validate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PolygonShape_Validate) + +static bool js_PolygonShape_m_centroid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_centroid, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PolygonShape_m_centroid_set) + +static bool js_PolygonShape_m_centroid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_centroid, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_centroid, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PolygonShape_m_centroid_get) + +static bool js_PolygonShape_m_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->m_count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PolygonShape_m_count_set) + +static bool js_PolygonShape_m_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PolygonShape *arg1 = (b2PolygonShape *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->m_count, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->m_count, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PolygonShape_m_count_get) + +static bool js_delete_b2PolygonShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PolygonShape) + +bool js_register_b2PolygonShape(se::Object* obj) { + auto* cls = se::Class::create("PolygonShape", obj, __jsb_b2Shape_proto, _SE(js_new_b2PolygonShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("m_centroid", _SE(js_PolygonShape_m_centroid_get), _SE(js_PolygonShape_m_centroid_set)); + cls->defineProperty("m_count", _SE(js_PolygonShape_m_count_get), _SE(js_PolygonShape_m_count_set)); + + cls->defineFunction("SetAsBox", _SE(js_PolygonShape_SetAsBox)); + cls->defineFunction("Validate", _SE(js_PolygonShape_Validate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PolygonShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PolygonShape_proto = cls->getProto(); + __jsb_b2PolygonShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Pair_class = nullptr; +se::Object* __jsb_b2Pair_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Pair) + +static bool js_Pair_proxyIdA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->proxyIdA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Pair_proxyIdA_set) + +static bool js_Pair_proxyIdA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->proxyIdA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->proxyIdA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Pair_proxyIdA_get) + +static bool js_Pair_proxyIdB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->proxyIdB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Pair_proxyIdB_set) + +static bool js_Pair_proxyIdB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Pair *arg1 = (b2Pair *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->proxyIdB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->proxyIdB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Pair_proxyIdB_get) + +static bool js_new_b2Pair(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Pair *result; + result = (b2Pair *)new b2Pair(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Pair, __jsb_b2Pair_class, js_delete_b2Pair) + +static bool js_delete_b2Pair(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Pair) + +template<> +bool sevalue_to_native(const se::Value &from, b2Pair * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("proxyIdA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->proxyIdA), ctx); + } + + + json->getProperty("proxyIdB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->proxyIdB), ctx); + } + + + return ok; +} + + +bool js_register_b2Pair(se::Object* obj) { + auto* cls = se::Class::create("Pair", obj, nullptr, _SE(js_new_b2Pair)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("proxyIdA", _SE(js_Pair_proxyIdA_get), _SE(js_Pair_proxyIdA_set)); + cls->defineProperty("proxyIdB", _SE(js_Pair_proxyIdB_get), _SE(js_Pair_proxyIdB_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Pair)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Pair_proto = cls->getProto(); + __jsb_b2Pair_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2BroadPhase_class = nullptr; +se::Object* __jsb_b2BroadPhase_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2BroadPhase) + +static bool js_new_b2BroadPhase(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2BroadPhase *result; + result = (b2BroadPhase *)new b2BroadPhase(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2BroadPhase, __jsb_b2BroadPhase_class, js_delete_b2BroadPhase) + +static bool js_delete_b2BroadPhase(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2BroadPhase) + +static bool js_BroadPhase_CreateProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + b2AABB *arg2 = 0 ; + void *arg3 = (void *) NULL ; + b2AABB temp2 ; + int32 result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + result = (arg1)->CreateProxy((b2AABB const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_CreateProxy) + +static bool js_BroadPhase_DestroyProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->DestroyProxy(arg2); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_DestroyProxy) + +static bool js_BroadPhase_MoveProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + b2AABB *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + b2AABB temp3 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->MoveProxy(arg2,(b2AABB const &)*arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_MoveProxy) + +static bool js_BroadPhase_TouchProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->TouchProxy(arg2); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_TouchProxy) + +static bool js_BroadPhase_GetFatAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + b2AABB *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (b2AABB *) &((b2BroadPhase const *)arg1)->GetFatAABB(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_BroadPhase_GetFatAABB) + +static bool js_BroadPhase_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + void *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (void *)((b2BroadPhase const *)arg1)->GetUserData(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_BroadPhase_GetUserData) + +static bool js_BroadPhase_TestOverlap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 arg2 ; + int32 arg3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((b2BroadPhase const *)arg1)->TestOverlap(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_TestOverlap) + +static bool js_BroadPhase_GetProxyCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2BroadPhase const *)arg1)->GetProxyCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetProxyCount) + +static bool js_BroadPhase_GetTreeHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2BroadPhase const *)arg1)->GetTreeHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetTreeHeight) + +static bool js_BroadPhase_GetTreeBalance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2BroadPhase const *)arg1)->GetTreeBalance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetTreeBalance) + +static bool js_BroadPhase_GetTreeQuality(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2BroadPhase const *)arg1)->GetTreeQuality(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_GetTreeQuality) + +static bool js_BroadPhase_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BroadPhase *arg1 = (b2BroadPhase *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_BroadPhase_ShiftOrigin) + +bool js_register_b2BroadPhase(se::Object* obj) { + auto* cls = se::Class::create("BroadPhase", obj, nullptr, _SE(js_new_b2BroadPhase)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("CreateProxy", _SE(js_BroadPhase_CreateProxy)); + cls->defineFunction("DestroyProxy", _SE(js_BroadPhase_DestroyProxy)); + cls->defineFunction("MoveProxy", _SE(js_BroadPhase_MoveProxy)); + cls->defineFunction("TouchProxy", _SE(js_BroadPhase_TouchProxy)); + cls->defineFunction("GetFatAABB", _SE(js_BroadPhase_GetFatAABB)); + cls->defineFunction("GetUserData", _SE(js_BroadPhase_GetUserData)); + cls->defineFunction("TestOverlap", _SE(js_BroadPhase_TestOverlap)); + cls->defineFunction("GetProxyCount", _SE(js_BroadPhase_GetProxyCount)); + cls->defineFunction("GetTreeHeight", _SE(js_BroadPhase_GetTreeHeight)); + cls->defineFunction("GetTreeBalance", _SE(js_BroadPhase_GetTreeBalance)); + cls->defineFunction("GetTreeQuality", _SE(js_BroadPhase_GetTreeQuality)); + cls->defineFunction("ShiftOrigin", _SE(js_BroadPhase_ShiftOrigin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2BroadPhase)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2BroadPhase_proto = cls->getProto(); + __jsb_b2BroadPhase_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2TreeNode_class = nullptr; +se::Object* __jsb_b2TreeNode_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2TreeNode) + +static bool js_TreeNode_IsLeaf(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2TreeNode const *)arg1)->IsLeaf(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_TreeNode_IsLeaf) + +static bool js_TreeNode_aabb_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->aabb, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_aabb_set) + +static bool js_TreeNode_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->aabb, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->aabb, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_aabb_get) + +static bool js_TreeNode_userData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->userData); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_userData_set) + +static bool js_TreeNode_userData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->userData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->userData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_userData_get) + +static bool js_TreeNode_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_parent_set) + +static bool js_TreeNode_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_parent_get) + +static bool js_TreeNode_next_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->next, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_next_set) + +static bool js_TreeNode_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->next, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->next, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_next_get) + +static bool js_TreeNode_child1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->child1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_child1_set) + +static bool js_TreeNode_child1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->child1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->child1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_child1_get) + +static bool js_TreeNode_child2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->child2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_child2_set) + +static bool js_TreeNode_child2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->child2, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->child2, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_child2_get) + +static bool js_TreeNode_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_height_set) + +static bool js_TreeNode_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->height, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_height_get) + +static bool js_TreeNode_moved_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->moved); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TreeNode_moved_set) + +static bool js_TreeNode_moved_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TreeNode *arg1 = (b2TreeNode *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->moved, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TreeNode_moved_get) + +static bool js_new_b2TreeNode(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2TreeNode *result; + result = (b2TreeNode *)new b2TreeNode(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2TreeNode, __jsb_b2TreeNode_class, js_delete_b2TreeNode) + +static bool js_delete_b2TreeNode(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2TreeNode) + +template<> +bool sevalue_to_native(const se::Value &from, b2TreeNode * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("aabb", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->aabb), ctx); + } + + + json->getProperty("userData", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->userData), ctx); + } + + + json->getProperty("parent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->parent), ctx); + } + + + json->getProperty("next", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->next), ctx); + } + + + json->getProperty("child1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->child1), ctx); + } + + + json->getProperty("child2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->child2), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("moved", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->moved), ctx); + } + + + return ok; +} + + +bool js_register_b2TreeNode(se::Object* obj) { + auto* cls = se::Class::create("TreeNode", obj, nullptr, _SE(js_new_b2TreeNode)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("aabb", _SE(js_TreeNode_aabb_get), _SE(js_TreeNode_aabb_set)); + cls->defineProperty("userData", _SE(js_TreeNode_userData_get), _SE(js_TreeNode_userData_set)); + cls->defineProperty("parent", _SE(js_TreeNode_parent_get), _SE(js_TreeNode_parent_set)); + cls->defineProperty("next", _SE(js_TreeNode_next_get), _SE(js_TreeNode_next_set)); + cls->defineProperty("child1", _SE(js_TreeNode_child1_get), _SE(js_TreeNode_child1_set)); + cls->defineProperty("child2", _SE(js_TreeNode_child2_get), _SE(js_TreeNode_child2_set)); + cls->defineProperty("height", _SE(js_TreeNode_height_get), _SE(js_TreeNode_height_set)); + cls->defineProperty("moved", _SE(js_TreeNode_moved_get), _SE(js_TreeNode_moved_set)); + + cls->defineFunction("IsLeaf", _SE(js_TreeNode_IsLeaf)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2TreeNode)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2TreeNode_proto = cls->getProto(); + __jsb_b2TreeNode_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DynamicTree_class = nullptr; +se::Object* __jsb_b2DynamicTree_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DynamicTree) + +static bool js_new_b2DynamicTree(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2DynamicTree *result; + result = (b2DynamicTree *)new b2DynamicTree(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2DynamicTree, __jsb_b2DynamicTree_class, js_delete_b2DynamicTree) + +static bool js_delete_b2DynamicTree(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DynamicTree) + +static bool js_DynamicTree_CreateProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + b2AABB *arg2 = 0 ; + void *arg3 = (void *) NULL ; + b2AABB temp2 ; + int32 result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + result = (arg1)->CreateProxy((b2AABB const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_CreateProxy) + +static bool js_DynamicTree_DestroyProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->DestroyProxy(arg2); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_DestroyProxy) + +static bool js_DynamicTree_MoveProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + b2AABB *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + b2AABB temp3 ; + b2Vec2 temp4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (bool)(arg1)->MoveProxy(arg2,(b2AABB const &)*arg3,(b2Vec2 const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_MoveProxy) + +static bool js_DynamicTree_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + void *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (void *)((b2DynamicTree const *)arg1)->GetUserData(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_DynamicTree_GetUserData) + +static bool js_DynamicTree_WasMoved(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((b2DynamicTree const *)arg1)->WasMoved(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_WasMoved) + +static bool js_DynamicTree_ClearMoved(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->ClearMoved(arg2); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_ClearMoved) + +static bool js_DynamicTree_GetFatAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 arg2 ; + b2AABB *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (b2AABB *) &((b2DynamicTree const *)arg1)->GetFatAABB(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_DynamicTree_GetFatAABB) + +static bool js_DynamicTree_Validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ((b2DynamicTree const *)arg1)->Validate(); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_Validate) + +static bool js_DynamicTree_GetHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2DynamicTree const *)arg1)->GetHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_GetHeight) + +static bool js_DynamicTree_GetMaxBalance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2DynamicTree const *)arg1)->GetMaxBalance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_GetMaxBalance) + +static bool js_DynamicTree_GetAreaRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DynamicTree const *)arg1)->GetAreaRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_GetAreaRatio) + +static bool js_DynamicTree_RebuildBottomUp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->RebuildBottomUp(); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_RebuildBottomUp) + +static bool js_DynamicTree_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DynamicTree *arg1 = (b2DynamicTree *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_DynamicTree_ShiftOrigin) + +bool js_register_b2DynamicTree(se::Object* obj) { + auto* cls = se::Class::create("DynamicTree", obj, nullptr, _SE(js_new_b2DynamicTree)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("CreateProxy", _SE(js_DynamicTree_CreateProxy)); + cls->defineFunction("DestroyProxy", _SE(js_DynamicTree_DestroyProxy)); + cls->defineFunction("MoveProxy", _SE(js_DynamicTree_MoveProxy)); + cls->defineFunction("GetUserData", _SE(js_DynamicTree_GetUserData)); + cls->defineFunction("WasMoved", _SE(js_DynamicTree_WasMoved)); + cls->defineFunction("ClearMoved", _SE(js_DynamicTree_ClearMoved)); + cls->defineFunction("GetFatAABB", _SE(js_DynamicTree_GetFatAABB)); + cls->defineFunction("Validate", _SE(js_DynamicTree_Validate)); + cls->defineFunction("GetHeight", _SE(js_DynamicTree_GetHeight)); + cls->defineFunction("GetMaxBalance", _SE(js_DynamicTree_GetMaxBalance)); + cls->defineFunction("GetAreaRatio", _SE(js_DynamicTree_GetAreaRatio)); + cls->defineFunction("RebuildBottomUp", _SE(js_DynamicTree_RebuildBottomUp)); + cls->defineFunction("ShiftOrigin", _SE(js_DynamicTree_ShiftOrigin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DynamicTree)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DynamicTree_proto = cls->getProto(); + __jsb_b2DynamicTree_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2BodyDef_class = nullptr; +se::Object* __jsb_b2BodyDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2BodyDef) + +static bool js_new_b2BodyDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2BodyDef *result; + result = (b2BodyDef *)new b2BodyDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2BodyDef, __jsb_b2BodyDef_class, js_delete_b2BodyDef) + +static bool js_BodyDef_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_type_set) + +static bool js_BodyDef_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_type_get) + +static bool js_BodyDef_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_position_set) + +static bool js_BodyDef_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_position_get) + +static bool js_BodyDef_angle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_angle_set) + +static bool js_BodyDef_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_angle_get) + +static bool js_BodyDef_linearVelocity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linearVelocity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_linearVelocity_set) + +static bool js_BodyDef_linearVelocity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linearVelocity, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linearVelocity, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_linearVelocity_get) + +static bool js_BodyDef_angularVelocity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularVelocity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_angularVelocity_set) + +static bool js_BodyDef_angularVelocity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularVelocity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_angularVelocity_get) + +static bool js_BodyDef_linearDamping_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linearDamping, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_linearDamping_set) + +static bool js_BodyDef_linearDamping_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linearDamping, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_linearDamping_get) + +static bool js_BodyDef_angularDamping_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularDamping, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_angularDamping_set) + +static bool js_BodyDef_angularDamping_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularDamping, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_angularDamping_get) + +static bool js_BodyDef_allowSleep_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->allowSleep); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_allowSleep_set) + +static bool js_BodyDef_allowSleep_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->allowSleep, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_allowSleep_get) + +static bool js_BodyDef_awake_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->awake); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_awake_set) + +static bool js_BodyDef_awake_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->awake, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_awake_get) + +static bool js_BodyDef_fixedRotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fixedRotation); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_fixedRotation_set) + +static bool js_BodyDef_fixedRotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fixedRotation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_fixedRotation_get) + +static bool js_BodyDef_bullet_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bullet); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_bullet_set) + +static bool js_BodyDef_bullet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bullet, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_bullet_get) + +static bool js_BodyDef_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_enabled_set) + +static bool js_BodyDef_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_enabled_get) + +static bool js_BodyDef_gravityScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->gravityScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_BodyDef_gravityScale_set) + +static bool js_BodyDef_gravityScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2BodyDef *arg1 = (b2BodyDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->gravityScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_BodyDef_gravityScale_get) + +static bool js_delete_b2BodyDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2BodyDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2BodyDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("position", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->position), ctx); + } + + + json->getProperty("angle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angle), ctx); + } + + + json->getProperty("linearVelocity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linearVelocity), ctx); + } + + + json->getProperty("angularVelocity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularVelocity), ctx); + } + + + json->getProperty("linearDamping", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linearDamping), ctx); + } + + + json->getProperty("angularDamping", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularDamping), ctx); + } + + + json->getProperty("allowSleep", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->allowSleep), ctx); + } + + + json->getProperty("awake", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->awake), ctx); + } + + + json->getProperty("fixedRotation", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->fixedRotation), ctx); + } + + + json->getProperty("bullet", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bullet), ctx); + } + + + json->getProperty("enabled", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enabled), ctx); + } + + + json->getProperty("gravityScale", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->gravityScale), ctx); + } + + + return ok; +} + + +bool js_register_b2BodyDef(se::Object* obj) { + auto* cls = se::Class::create("BodyDef", obj, nullptr, _SE(js_new_b2BodyDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_BodyDef_type_get), _SE(js_BodyDef_type_set)); + cls->defineProperty("position", _SE(js_BodyDef_position_get), _SE(js_BodyDef_position_set)); + cls->defineProperty("angle", _SE(js_BodyDef_angle_get), _SE(js_BodyDef_angle_set)); + cls->defineProperty("linearVelocity", _SE(js_BodyDef_linearVelocity_get), _SE(js_BodyDef_linearVelocity_set)); + cls->defineProperty("angularVelocity", _SE(js_BodyDef_angularVelocity_get), _SE(js_BodyDef_angularVelocity_set)); + cls->defineProperty("linearDamping", _SE(js_BodyDef_linearDamping_get), _SE(js_BodyDef_linearDamping_set)); + cls->defineProperty("angularDamping", _SE(js_BodyDef_angularDamping_get), _SE(js_BodyDef_angularDamping_set)); + cls->defineProperty("allowSleep", _SE(js_BodyDef_allowSleep_get), _SE(js_BodyDef_allowSleep_set)); + cls->defineProperty("awake", _SE(js_BodyDef_awake_get), _SE(js_BodyDef_awake_set)); + cls->defineProperty("fixedRotation", _SE(js_BodyDef_fixedRotation_get), _SE(js_BodyDef_fixedRotation_set)); + cls->defineProperty("bullet", _SE(js_BodyDef_bullet_get), _SE(js_BodyDef_bullet_set)); + cls->defineProperty("enabled", _SE(js_BodyDef_enabled_get), _SE(js_BodyDef_enabled_set)); + cls->defineProperty("gravityScale", _SE(js_BodyDef_gravityScale_get), _SE(js_BodyDef_gravityScale_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2BodyDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2BodyDef_proto = cls->getProto(); + __jsb_b2BodyDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Body_class = nullptr; +se::Object* __jsb_b2Body_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Body) + +static bool js_Body_CreateFixture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2FixtureDef *arg2 = (b2FixtureDef *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Fixture *)(arg1)->CreateFixture((b2FixtureDef 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; +} + +static bool js_Body_CreateFixture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Shape *arg2 = (b2Shape *) NULL ; + float arg3 ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (b2Fixture *)(arg1)->CreateFixture((b2Shape 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; +} + +static bool js_Body_CreateFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_Body_CreateFixture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_Body_CreateFixture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_CreateFixture) + +static bool js_Body_DestroyFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->DestroyFixture(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_DestroyFixture) + +static bool js_Body_SetTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetTransform((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_SetTransform) + +static bool js_Body_GetTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Transform *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(s); + if (nullptr == arg1) return true; + result = (b2Transform *) &((b2Body const *)arg1)->GetTransform(); + + 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_Body_GetTransform) + +static bool js_Body_GetPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetPosition(); + + 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_Body_GetPosition) + +static bool js_Body_GetAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetAngle) + +static bool js_Body_GetWorldCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetWorldCenter(); + + 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_Body_GetWorldCenter) + +static bool js_Body_GetLocalCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetLocalCenter(); + + 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_Body_GetLocalCenter) + +static bool js_Body_SetLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLinearVelocity((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetLinearVelocity) + +static bool js_Body_GetLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2Body const *)arg1)->GetLinearVelocity(); + + 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_Body_GetLinearVelocity) + +static bool js_Body_SetAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAngularVelocity(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetAngularVelocity) + +static bool js_Body_GetAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetAngularVelocity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetAngularVelocity) + +static bool js_Body_ApplyForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + bool arg4 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyForce((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyForce) + +static bool js_Body_ApplyForceToCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + bool arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ApplyForceToCenter((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyForceToCenter) + +static bool js_Body_ApplyTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyTorque(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyTorque) + +static bool js_Body_ApplyLinearImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + bool arg4 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyLinearImpulse((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyLinearImpulse) + +static bool js_Body_ApplyLinearImpulseToCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + bool arg3 ; + b2Vec2 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ApplyLinearImpulseToCenter((b2Vec2 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyLinearImpulseToCenter) + +static bool js_Body_ApplyAngularImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->ApplyAngularImpulse(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_Body_ApplyAngularImpulse) + +static bool js_Body_GetMass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetMass(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetMass) + +static bool js_Body_GetInertia(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetInertia(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetInertia) + +static bool js_Body_GetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Body const *)arg1)->GetMassData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_GetMassData) + +static bool js_Body_SetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMassData((b2MassData const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetMassData) + +static bool js_Body_ResetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ResetMassData(); + + + return true; +} +SE_BIND_FUNC(js_Body_ResetMassData) + +static bool js_Body_GetWorldPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetWorldPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetWorldPoint) + +static bool js_Body_GetWorldVector(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetWorldVector((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetWorldVector) + +static bool js_Body_GetLocalPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLocalPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLocalPoint) + +static bool js_Body_GetLocalVector(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLocalVector((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLocalVector) + +static bool js_Body_GetLinearVelocityFromWorldPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLinearVelocityFromWorldPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLinearVelocityFromWorldPoint) + +static bool js_Body_GetLinearVelocityFromLocalPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + b2Vec2 result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = ((b2Body const *)arg1)->GetLinearVelocityFromLocalPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetLinearVelocityFromLocalPoint) + +static bool js_Body_GetLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetLinearDamping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetLinearDamping) + +static bool js_Body_SetLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetLinearDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetLinearDamping) + +static bool js_Body_GetAngularDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetAngularDamping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetAngularDamping) + +static bool js_Body_SetAngularDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAngularDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetAngularDamping) + +static bool js_Body_GetGravityScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Body const *)arg1)->GetGravityScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_GetGravityScale) + +static bool js_Body_SetGravityScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetGravityScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetGravityScale) + +static bool js_Body_SetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2BodyType arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->SetType(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetType) + +static bool js_Body_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + b2BodyType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2BodyType)((b2Body const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Body_GetType) + +static bool js_Body_SetBullet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetBullet(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetBullet) + +static bool js_Body_IsBullet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsBullet(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsBullet) + +static bool js_Body_SetSleepingAllowed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSleepingAllowed(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetSleepingAllowed) + +static bool js_Body_IsSleepingAllowed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsSleepingAllowed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsSleepingAllowed) + +static bool js_Body_SetAwake(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAwake(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetAwake) + +static bool js_Body_IsAwake(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsAwake(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsAwake) + +static bool js_Body_SetEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetEnabled) + +static bool js_Body_IsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsEnabled) + +static bool js_Body_SetFixedRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFixedRotation(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetFixedRotation) + +static bool js_Body_IsFixedRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Body const *)arg1)->IsFixedRotation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Body_IsFixedRotation) + +static bool js_Body_GetFixtureList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetFixtureList(); + + 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_Body_GetFixtureList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Body const *)arg1)->GetFixtureList(); + + 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_Body_GetFixtureList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetFixtureList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetFixtureList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetFixtureList) + +static bool js_Body_GetJointList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2JointEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2JointEdge *)(arg1)->GetJointList(); + + 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_Body_GetJointList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2JointEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2JointEdge *)((b2Body const *)arg1)->GetJointList(); + + 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_Body_GetJointList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetJointList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetJointList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetJointList) + +static bool js_Body_GetContactList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2ContactEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2ContactEdge *)(arg1)->GetContactList(); + + 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_Body_GetContactList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2ContactEdge *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2ContactEdge *)((b2Body const *)arg1)->GetContactList(); + + 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_Body_GetContactList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetContactList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetContactList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetContactList) + +static bool js_Body_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetNext(); + + 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_Body_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)((b2Body const *)arg1)->GetNext(); + + 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_Body_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetNext) + +static bool js_Body_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((b2Body const *)arg1)->GetUserData(); + + 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_Body_GetUserData) + +static bool js_Body_SetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetUserData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Body_SetUserData) + +static bool js_Body_GetWorld__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2World *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2World *)(arg1)->GetWorld(); + + 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_Body_GetWorld__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Body *arg1 = (b2Body *) NULL ; + b2World *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2World *)((b2Body const *)arg1)->GetWorld(); + + 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_Body_GetWorld(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Body_GetWorld__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Body_GetWorld__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Body_GetWorld) + +static bool js_Body_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Body *arg1 = (b2Body *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Dump(); + + + return true; +} +SE_BIND_FUNC(js_Body_Dump) + +bool js_register_b2Body(se::Object* obj) { + auto* cls = se::Class::create("Body", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("CreateFixture", _SE(js_Body_CreateFixture)); + cls->defineFunction("DestroyFixture", _SE(js_Body_DestroyFixture)); + cls->defineFunction("SetTransform", _SE(js_Body_SetTransform)); + cls->defineFunction("GetTransform", _SE(js_Body_GetTransform)); + cls->defineFunction("GetPosition", _SE(js_Body_GetPosition)); + cls->defineFunction("GetAngle", _SE(js_Body_GetAngle)); + cls->defineFunction("GetWorldCenter", _SE(js_Body_GetWorldCenter)); + cls->defineFunction("GetLocalCenter", _SE(js_Body_GetLocalCenter)); + cls->defineFunction("SetLinearVelocity", _SE(js_Body_SetLinearVelocity)); + cls->defineFunction("GetLinearVelocity", _SE(js_Body_GetLinearVelocity)); + cls->defineFunction("SetAngularVelocity", _SE(js_Body_SetAngularVelocity)); + cls->defineFunction("GetAngularVelocity", _SE(js_Body_GetAngularVelocity)); + cls->defineFunction("ApplyForce", _SE(js_Body_ApplyForce)); + cls->defineFunction("ApplyForceToCenter", _SE(js_Body_ApplyForceToCenter)); + cls->defineFunction("ApplyTorque", _SE(js_Body_ApplyTorque)); + cls->defineFunction("ApplyLinearImpulse", _SE(js_Body_ApplyLinearImpulse)); + cls->defineFunction("ApplyLinearImpulseToCenter", _SE(js_Body_ApplyLinearImpulseToCenter)); + cls->defineFunction("ApplyAngularImpulse", _SE(js_Body_ApplyAngularImpulse)); + cls->defineFunction("GetMass", _SE(js_Body_GetMass)); + cls->defineFunction("GetInertia", _SE(js_Body_GetInertia)); + cls->defineFunction("GetMassData", _SE(js_Body_GetMassData)); + cls->defineFunction("SetMassData", _SE(js_Body_SetMassData)); + cls->defineFunction("ResetMassData", _SE(js_Body_ResetMassData)); + cls->defineFunction("GetWorldPoint", _SE(js_Body_GetWorldPoint)); + cls->defineFunction("GetWorldVector", _SE(js_Body_GetWorldVector)); + cls->defineFunction("GetLocalPoint", _SE(js_Body_GetLocalPoint)); + cls->defineFunction("GetLocalVector", _SE(js_Body_GetLocalVector)); + cls->defineFunction("GetLinearVelocityFromWorldPoint", _SE(js_Body_GetLinearVelocityFromWorldPoint)); + cls->defineFunction("GetLinearVelocityFromLocalPoint", _SE(js_Body_GetLinearVelocityFromLocalPoint)); + cls->defineFunction("GetLinearDamping", _SE(js_Body_GetLinearDamping)); + cls->defineFunction("SetLinearDamping", _SE(js_Body_SetLinearDamping)); + cls->defineFunction("GetAngularDamping", _SE(js_Body_GetAngularDamping)); + cls->defineFunction("SetAngularDamping", _SE(js_Body_SetAngularDamping)); + cls->defineFunction("GetGravityScale", _SE(js_Body_GetGravityScale)); + cls->defineFunction("SetGravityScale", _SE(js_Body_SetGravityScale)); + cls->defineFunction("SetType", _SE(js_Body_SetType)); + cls->defineFunction("GetType", _SE(js_Body_GetType)); + cls->defineFunction("SetBullet", _SE(js_Body_SetBullet)); + cls->defineFunction("IsBullet", _SE(js_Body_IsBullet)); + cls->defineFunction("SetSleepingAllowed", _SE(js_Body_SetSleepingAllowed)); + cls->defineFunction("IsSleepingAllowed", _SE(js_Body_IsSleepingAllowed)); + cls->defineFunction("SetAwake", _SE(js_Body_SetAwake)); + cls->defineFunction("IsAwake", _SE(js_Body_IsAwake)); + cls->defineFunction("SetEnabled", _SE(js_Body_SetEnabled)); + cls->defineFunction("IsEnabled", _SE(js_Body_IsEnabled)); + cls->defineFunction("SetFixedRotation", _SE(js_Body_SetFixedRotation)); + cls->defineFunction("IsFixedRotation", _SE(js_Body_IsFixedRotation)); + cls->defineFunction("GetFixtureList", _SE(js_Body_GetFixtureList)); + cls->defineFunction("GetJointList", _SE(js_Body_GetJointList)); + cls->defineFunction("GetContactList", _SE(js_Body_GetContactList)); + cls->defineFunction("GetNext", _SE(js_Body_GetNext)); + cls->defineFunction("GetUserData", _SE(js_Body_GetUserData)); + cls->defineFunction("SetUserData", _SE(js_Body_SetUserData)); + cls->defineFunction("GetWorld", _SE(js_Body_GetWorld)); + cls->defineFunction("Dump", _SE(js_Body_Dump)); + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Body_proto = cls->getProto(); + __jsb_b2Body_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_b2MixFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)b2MixFriction(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2MixFriction) + +static bool js_b2MixRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)b2MixRestitution(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_b2MixRestitution) + +se::Class* __jsb_b2ContactEdge_class = nullptr; +se::Object* __jsb_b2ContactEdge_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactEdge) + +static bool js_ContactEdge_other_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->other, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_other_set) + +static bool js_ContactEdge_other_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->other, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->other, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_other_get) + +static bool js_ContactEdge_contact_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->contact, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_contact_set) + +static bool js_ContactEdge_contact_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->contact, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->contact, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_contact_get) + +static bool js_ContactEdge_prev_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prev, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_prev_set) + +static bool js_ContactEdge_prev_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prev, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prev, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_prev_get) + +static bool js_ContactEdge_next_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->next, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_ContactEdge_next_set) + +static bool js_ContactEdge_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactEdge *arg1 = (b2ContactEdge *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->next, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->next, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_ContactEdge_next_get) + +static bool js_new_b2ContactEdge(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactEdge *result; + result = (b2ContactEdge *)new b2ContactEdge(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactEdge, __jsb_b2ContactEdge_class, js_delete_b2ContactEdge) + +static bool js_delete_b2ContactEdge(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactEdge) + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactEdge * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("other", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->other), ctx); + } + + + json->getProperty("contact", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->contact), ctx); + } + + + json->getProperty("prev", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prev), ctx); + } + + + json->getProperty("next", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->next), ctx); + } + + + return ok; +} + + +bool js_register_b2ContactEdge(se::Object* obj) { + auto* cls = se::Class::create("ContactEdge", obj, nullptr, _SE(js_new_b2ContactEdge)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("other", _SE(js_ContactEdge_other_get), _SE(js_ContactEdge_other_set)); + cls->defineProperty("contact", _SE(js_ContactEdge_contact_get), _SE(js_ContactEdge_contact_set)); + cls->defineProperty("prev", _SE(js_ContactEdge_prev_get), _SE(js_ContactEdge_prev_set)); + cls->defineProperty("next", _SE(js_ContactEdge_next_get), _SE(js_ContactEdge_next_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactEdge)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactEdge_proto = cls->getProto(); + __jsb_b2ContactEdge_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Contact_class = nullptr; +se::Object* __jsb_b2Contact_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Contact) + +static bool js_Contact_GetManifold__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Manifold *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Manifold *)(arg1)->GetManifold(); + + 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_Contact_GetManifold__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Manifold *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Manifold *)((b2Contact const *)arg1)->GetManifold(); + + 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_Contact_GetManifold(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetManifold__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetManifold__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetManifold) + +static bool js_Contact_IsTouching(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Contact const *)arg1)->IsTouching(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_IsTouching) + +static bool js_Contact_SetEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetEnabled) + +static bool js_Contact_IsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Contact const *)arg1)->IsEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_IsEnabled) + +static bool js_Contact_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)(arg1)->GetNext(); + + 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_Contact_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)((b2Contact const *)arg1)->GetNext(); + + 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_Contact_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetNext) + +static bool js_Contact_GetFixtureA__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetFixtureA(); + + 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_Contact_GetFixtureA__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Contact const *)arg1)->GetFixtureA(); + + 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_Contact_GetFixtureA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetFixtureA__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetFixtureA__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetFixtureA) + +static bool js_Contact_GetChildIndexA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Contact const *)arg1)->GetChildIndexA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Contact_GetChildIndexA) + +static bool js_Contact_GetFixtureB__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetFixtureB(); + + 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_Contact_GetFixtureB__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Contact const *)arg1)->GetFixtureB(); + + 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_Contact_GetFixtureB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Contact_GetFixtureB__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Contact_GetFixtureB__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Contact_GetFixtureB) + +static bool js_Contact_GetChildIndexB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2Contact const *)arg1)->GetChildIndexB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Contact_GetChildIndexB) + +static bool js_Contact_SetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFriction(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetFriction) + +static bool js_Contact_GetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Contact const *)arg1)->GetFriction(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_GetFriction) + +static bool js_Contact_ResetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ResetFriction(); + + + return true; +} +SE_BIND_FUNC(js_Contact_ResetFriction) + +static bool js_Contact_SetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetRestitution) + +static bool js_Contact_GetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Contact const *)arg1)->GetRestitution(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_GetRestitution) + +static bool js_Contact_ResetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ResetRestitution(); + + + return true; +} +SE_BIND_FUNC(js_Contact_ResetRestitution) + +static bool js_Contact_SetTangentSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetTangentSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_Contact_SetTangentSpeed) + +static bool js_Contact_GetTangentSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Contact const *)arg1)->GetTangentSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Contact_GetTangentSpeed) + +static bool js_Contact_Evaluate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Contact *arg1 = (b2Contact *) NULL ; + b2Manifold *arg2 = (b2Manifold *) NULL ; + b2Transform *arg3 = 0 ; + b2Transform *arg4 = 0 ; + b2Transform temp3 ; + b2Transform temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->Evaluate(arg2,(b2Transform const &)*arg3,(b2Transform const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Contact_Evaluate) + +bool js_register_b2Contact(se::Object* obj) { + auto* cls = se::Class::create("Contact", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetManifold", _SE(js_Contact_GetManifold)); + cls->defineFunction("IsTouching", _SE(js_Contact_IsTouching)); + cls->defineFunction("SetEnabled", _SE(js_Contact_SetEnabled)); + cls->defineFunction("IsEnabled", _SE(js_Contact_IsEnabled)); + cls->defineFunction("GetNext", _SE(js_Contact_GetNext)); + cls->defineFunction("GetFixtureA", _SE(js_Contact_GetFixtureA)); + cls->defineFunction("GetChildIndexA", _SE(js_Contact_GetChildIndexA)); + cls->defineFunction("GetFixtureB", _SE(js_Contact_GetFixtureB)); + cls->defineFunction("GetChildIndexB", _SE(js_Contact_GetChildIndexB)); + cls->defineFunction("SetFriction", _SE(js_Contact_SetFriction)); + cls->defineFunction("GetFriction", _SE(js_Contact_GetFriction)); + cls->defineFunction("ResetFriction", _SE(js_Contact_ResetFriction)); + cls->defineFunction("SetRestitution", _SE(js_Contact_SetRestitution)); + cls->defineFunction("GetRestitution", _SE(js_Contact_GetRestitution)); + cls->defineFunction("ResetRestitution", _SE(js_Contact_ResetRestitution)); + cls->defineFunction("SetTangentSpeed", _SE(js_Contact_SetTangentSpeed)); + cls->defineFunction("GetTangentSpeed", _SE(js_Contact_GetTangentSpeed)); + cls->defineFunction("Evaluate", _SE(js_Contact_Evaluate)); + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Contact_proto = cls->getProto(); + __jsb_b2Contact_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Filter_class = nullptr; +se::Object* __jsb_b2Filter_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Filter) + +static bool js_new_b2Filter(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Filter *result; + result = (b2Filter *)new b2Filter(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Filter, __jsb_b2Filter_class, js_delete_b2Filter) + +static bool js_Filter_categoryBits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->categoryBits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Filter_categoryBits_set) + +static bool js_Filter_categoryBits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->categoryBits, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->categoryBits, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Filter_categoryBits_get) + +static bool js_Filter_maskBits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maskBits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Filter_maskBits_set) + +static bool js_Filter_maskBits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maskBits, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maskBits, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Filter_maskBits_get) + +static bool js_Filter_groupIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Filter_groupIndex_set) + +static bool js_Filter_groupIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Filter *arg1 = (b2Filter *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->groupIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Filter_groupIndex_get) + +static bool js_delete_b2Filter(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Filter) + +template<> +bool sevalue_to_native(const se::Value &from, b2Filter * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("categoryBits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->categoryBits), ctx); + } + + + json->getProperty("maskBits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maskBits), ctx); + } + + + json->getProperty("groupIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupIndex), ctx); + } + + + return ok; +} + + +bool js_register_b2Filter(se::Object* obj) { + auto* cls = se::Class::create("Filter", obj, nullptr, _SE(js_new_b2Filter)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("categoryBits", _SE(js_Filter_categoryBits_get), _SE(js_Filter_categoryBits_set)); + cls->defineProperty("maskBits", _SE(js_Filter_maskBits_get), _SE(js_Filter_maskBits_set)); + cls->defineProperty("groupIndex", _SE(js_Filter_groupIndex_get), _SE(js_Filter_groupIndex_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Filter)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Filter_proto = cls->getProto(); + __jsb_b2Filter_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FixtureDef_class = nullptr; +se::Object* __jsb_b2FixtureDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FixtureDef) + +static bool js_new_b2FixtureDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2FixtureDef *result; + result = (b2FixtureDef *)new b2FixtureDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2FixtureDef, __jsb_b2FixtureDef_class, js_delete_b2FixtureDef) + +static bool js_FixtureDef_shape_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shape, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_shape_set) + +static bool js_FixtureDef_shape_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shape, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shape, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_shape_get) + +static bool js_FixtureDef_friction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->friction, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_friction_set) + +static bool js_FixtureDef_friction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->friction, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_friction_get) + +static bool js_FixtureDef_restitution_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->restitution, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_restitution_set) + +static bool js_FixtureDef_restitution_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->restitution, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_restitution_get) + +static bool js_FixtureDef_density_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->density, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_density_set) + +static bool js_FixtureDef_density_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->density, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_density_get) + +static bool js_FixtureDef_isSensor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isSensor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_isSensor_set) + +static bool js_FixtureDef_isSensor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isSensor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_isSensor_get) + +static bool js_FixtureDef_filter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->filter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureDef_filter_set) + +static bool js_FixtureDef_filter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureDef *arg1 = (b2FixtureDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->filter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->filter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureDef_filter_get) + +static bool js_delete_b2FixtureDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FixtureDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("shape", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shape), ctx); + } + + + json->getProperty("friction", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->friction), ctx); + } + + + json->getProperty("restitution", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->restitution), ctx); + } + + + json->getProperty("density", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->density), ctx); + } + + + json->getProperty("isSensor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isSensor), ctx); + } + + + json->getProperty("filter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->filter), ctx); + } + + + return ok; +} + + +bool js_register_b2FixtureDef(se::Object* obj) { + auto* cls = se::Class::create("FixtureDef", obj, nullptr, _SE(js_new_b2FixtureDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("shape", _SE(js_FixtureDef_shape_get), _SE(js_FixtureDef_shape_set)); + cls->defineProperty("friction", _SE(js_FixtureDef_friction_get), _SE(js_FixtureDef_friction_set)); + cls->defineProperty("restitution", _SE(js_FixtureDef_restitution_get), _SE(js_FixtureDef_restitution_set)); + cls->defineProperty("density", _SE(js_FixtureDef_density_get), _SE(js_FixtureDef_density_set)); + cls->defineProperty("isSensor", _SE(js_FixtureDef_isSensor_get), _SE(js_FixtureDef_isSensor_set)); + cls->defineProperty("filter", _SE(js_FixtureDef_filter_get), _SE(js_FixtureDef_filter_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FixtureDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FixtureDef_proto = cls->getProto(); + __jsb_b2FixtureDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FixtureProxy_class = nullptr; +se::Object* __jsb_b2FixtureProxy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FixtureProxy) + +static bool js_FixtureProxy_aabb_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->aabb, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_aabb_set) + +static bool js_FixtureProxy_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->aabb, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->aabb, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_aabb_get) + +static bool js_FixtureProxy_fixture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fixture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_fixture_set) + +static bool js_FixtureProxy_fixture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fixture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->fixture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_fixture_get) + +static bool js_FixtureProxy_childIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->childIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_childIndex_set) + +static bool js_FixtureProxy_childIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->childIndex, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->childIndex, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_childIndex_get) + +static bool js_FixtureProxy_proxyId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->proxyId, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FixtureProxy_proxyId_set) + +static bool js_FixtureProxy_proxyId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FixtureProxy *arg1 = (b2FixtureProxy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->proxyId, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->proxyId, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FixtureProxy_proxyId_get) + +static bool js_new_b2FixtureProxy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2FixtureProxy *result; + result = (b2FixtureProxy *)new b2FixtureProxy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2FixtureProxy, __jsb_b2FixtureProxy_class, js_delete_b2FixtureProxy) + +static bool js_delete_b2FixtureProxy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FixtureProxy) + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureProxy * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("aabb", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->aabb), ctx); + } + + + json->getProperty("fixture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->fixture), ctx); + } + + + json->getProperty("childIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->childIndex), ctx); + } + + + json->getProperty("proxyId", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->proxyId), ctx); + } + + + return ok; +} + + +bool js_register_b2FixtureProxy(se::Object* obj) { + auto* cls = se::Class::create("FixtureProxy", obj, nullptr, _SE(js_new_b2FixtureProxy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("aabb", _SE(js_FixtureProxy_aabb_get), _SE(js_FixtureProxy_aabb_set)); + cls->defineProperty("fixture", _SE(js_FixtureProxy_fixture_get), _SE(js_FixtureProxy_fixture_set)); + cls->defineProperty("childIndex", _SE(js_FixtureProxy_childIndex_get), _SE(js_FixtureProxy_childIndex_set)); + cls->defineProperty("proxyId", _SE(js_FixtureProxy_proxyId_get), _SE(js_FixtureProxy_proxyId_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FixtureProxy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FixtureProxy_proto = cls->getProto(); + __jsb_b2FixtureProxy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Fixture_class = nullptr; +se::Object* __jsb_b2Fixture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Fixture) + +static bool js_Fixture_GetType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Shape::Type result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape::Type)((b2Fixture const *)arg1)->GetType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetType) + +static bool js_Fixture_GetShape__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Shape *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape *)(arg1)->GetShape(); + + 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_Fixture_GetShape__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Shape *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Shape *)((b2Fixture const *)arg1)->GetShape(); + + 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_Fixture_GetShape(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Fixture_GetShape__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Fixture_GetShape__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Fixture_GetShape) + +static bool js_Fixture_SetSensor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSensor(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetSensor) + +static bool js_Fixture_IsSensor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2Fixture const *)arg1)->IsSensor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_IsSensor) + +static bool js_Fixture_SetFilterData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Filter *arg2 = 0 ; + b2Filter temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetFilterData((b2Filter const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetFilterData) + +static bool js_Fixture_GetFilterData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Filter *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(s); + if (nullptr == arg1) return true; + result = (b2Filter *) &((b2Fixture const *)arg1)->GetFilterData(); + + 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_Fixture_GetFilterData) + +static bool js_Fixture_Refilter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Refilter(); + + + return true; +} +SE_BIND_FUNC(js_Fixture_Refilter) + +static bool js_Fixture_GetBody__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBody(); + + 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_Fixture_GetBody__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)((b2Fixture const *)arg1)->GetBody(); + + 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_Fixture_GetBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Fixture_GetBody__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Fixture_GetBody__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Fixture_GetBody) + +static bool js_Fixture_GetNext__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)(arg1)->GetNext(); + + 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_Fixture_GetNext__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Fixture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Fixture *)((b2Fixture const *)arg1)->GetNext(); + + 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_Fixture_GetNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_Fixture_GetNext__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_Fixture_GetNext__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_Fixture_GetNext) + +static bool js_Fixture_GetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((b2Fixture const *)arg1)->GetUserData(); + + 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_Fixture_GetUserData) + +static bool js_Fixture_SetUserData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetUserData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetUserData) + +static bool js_Fixture_TestPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 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(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)((b2Fixture const *)arg1)->TestPoint((b2Vec2 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_TestPoint) + +static bool js_Fixture_RayCast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2RayCastOutput *arg2 = (b2RayCastOutput *) NULL ; + b2RayCastInput *arg3 = 0 ; + int32 arg4 ; + b2RayCastInput temp3 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((b2Fixture const *)arg1)->RayCast(arg2,(b2RayCastInput const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_RayCast) + +static bool js_Fixture_GetMassData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + b2MassData *arg2 = (b2MassData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((b2Fixture const *)arg1)->GetMassData(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetMassData) + +static bool js_Fixture_SetDensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDensity(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetDensity) + +static bool js_Fixture_GetDensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Fixture const *)arg1)->GetDensity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetDensity) + +static bool js_Fixture_GetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Fixture const *)arg1)->GetFriction(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetFriction) + +static bool js_Fixture_SetFriction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFriction(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetFriction) + +static bool js_Fixture_GetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2Fixture const *)arg1)->GetRestitution(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_Fixture_GetRestitution) + +static bool js_Fixture_SetRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_SetRestitution) + +static bool js_Fixture_GetAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + int32 arg2 ; + b2AABB *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (b2AABB *) &((b2Fixture const *)arg1)->GetAABB(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_Fixture_GetAABB) + +static bool js_Fixture_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Fixture *arg1 = (b2Fixture *) NULL ; + int32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->Dump(arg2); + + + return true; +} +SE_BIND_FUNC(js_Fixture_Dump) + +static bool js_delete_b2Fixture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Fixture) + +bool js_register_b2Fixture(se::Object* obj) { + auto* cls = se::Class::create("Fixture", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetType", _SE(js_Fixture_GetType)); + cls->defineFunction("GetShape", _SE(js_Fixture_GetShape)); + cls->defineFunction("SetSensor", _SE(js_Fixture_SetSensor)); + cls->defineFunction("IsSensor", _SE(js_Fixture_IsSensor)); + cls->defineFunction("SetFilterData", _SE(js_Fixture_SetFilterData)); + cls->defineFunction("GetFilterData", _SE(js_Fixture_GetFilterData)); + cls->defineFunction("Refilter", _SE(js_Fixture_Refilter)); + cls->defineFunction("GetBody", _SE(js_Fixture_GetBody)); + cls->defineFunction("GetNext", _SE(js_Fixture_GetNext)); + cls->defineFunction("GetUserData", _SE(js_Fixture_GetUserData)); + cls->defineFunction("SetUserData", _SE(js_Fixture_SetUserData)); + cls->defineFunction("TestPoint", _SE(js_Fixture_TestPoint)); + cls->defineFunction("RayCast", _SE(js_Fixture_RayCast)); + cls->defineFunction("GetMassData", _SE(js_Fixture_GetMassData)); + cls->defineFunction("SetDensity", _SE(js_Fixture_SetDensity)); + cls->defineFunction("GetDensity", _SE(js_Fixture_GetDensity)); + cls->defineFunction("GetFriction", _SE(js_Fixture_GetFriction)); + cls->defineFunction("SetFriction", _SE(js_Fixture_SetFriction)); + cls->defineFunction("GetRestitution", _SE(js_Fixture_GetRestitution)); + cls->defineFunction("SetRestitution", _SE(js_Fixture_SetRestitution)); + cls->defineFunction("GetAABB", _SE(js_Fixture_GetAABB)); + cls->defineFunction("Dump", _SE(js_Fixture_Dump)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Fixture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Fixture_proto = cls->getProto(); + __jsb_b2Fixture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Profile_class = nullptr; +se::Object* __jsb_b2Profile_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Profile) + +static bool js_Profile_step_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->step, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_step_set) + +static bool js_Profile_step_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->step, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_step_get) + +static bool js_Profile_collide_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->collide, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_collide_set) + +static bool js_Profile_collide_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->collide, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_collide_get) + +static bool js_Profile_solve_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solve, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solve_set) + +static bool js_Profile_solve_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solve, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solve_get) + +static bool js_Profile_solveInit_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solveInit, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solveInit_set) + +static bool js_Profile_solveInit_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solveInit, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solveInit_get) + +static bool js_Profile_solveVelocity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solveVelocity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solveVelocity_set) + +static bool js_Profile_solveVelocity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solveVelocity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solveVelocity_get) + +static bool js_Profile_solvePosition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solvePosition, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solvePosition_set) + +static bool js_Profile_solvePosition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solvePosition, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solvePosition_get) + +static bool js_Profile_broadphase_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->broadphase, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_broadphase_set) + +static bool js_Profile_broadphase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->broadphase, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_broadphase_get) + +static bool js_Profile_solveTOI_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->solveTOI, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Profile_solveTOI_set) + +static bool js_Profile_solveTOI_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Profile *arg1 = (b2Profile *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->solveTOI, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Profile_solveTOI_get) + +static bool js_new_b2Profile(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Profile *result; + result = (b2Profile *)new b2Profile(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Profile, __jsb_b2Profile_class, js_delete_b2Profile) + +static bool js_delete_b2Profile(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Profile) + +template<> +bool sevalue_to_native(const se::Value &from, b2Profile * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("step", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->step), ctx); + } + + + json->getProperty("collide", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->collide), ctx); + } + + + json->getProperty("solve", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solve), ctx); + } + + + json->getProperty("solveInit", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solveInit), ctx); + } + + + json->getProperty("solveVelocity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solveVelocity), ctx); + } + + + json->getProperty("solvePosition", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solvePosition), ctx); + } + + + json->getProperty("broadphase", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->broadphase), ctx); + } + + + json->getProperty("solveTOI", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->solveTOI), ctx); + } + + + return ok; +} + + +bool js_register_b2Profile(se::Object* obj) { + auto* cls = se::Class::create("Profile", obj, nullptr, _SE(js_new_b2Profile)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("step", _SE(js_Profile_step_get), _SE(js_Profile_step_set)); + cls->defineProperty("collide", _SE(js_Profile_collide_get), _SE(js_Profile_collide_set)); + cls->defineProperty("solve", _SE(js_Profile_solve_get), _SE(js_Profile_solve_set)); + cls->defineProperty("solveInit", _SE(js_Profile_solveInit_get), _SE(js_Profile_solveInit_set)); + cls->defineProperty("solveVelocity", _SE(js_Profile_solveVelocity_get), _SE(js_Profile_solveVelocity_set)); + cls->defineProperty("solvePosition", _SE(js_Profile_solvePosition_get), _SE(js_Profile_solvePosition_set)); + cls->defineProperty("broadphase", _SE(js_Profile_broadphase_get), _SE(js_Profile_broadphase_set)); + cls->defineProperty("solveTOI", _SE(js_Profile_solveTOI_get), _SE(js_Profile_solveTOI_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Profile)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Profile_proto = cls->getProto(); + __jsb_b2Profile_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2TimeStep_class = nullptr; +se::Object* __jsb_b2TimeStep_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2TimeStep) + +static bool js_TimeStep_dt_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dt, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_dt_set) + +static bool js_TimeStep_dt_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dt, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_dt_get) + +static bool js_TimeStep_inv_dt_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inv_dt, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_inv_dt_set) + +static bool js_TimeStep_inv_dt_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inv_dt, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_inv_dt_get) + +static bool js_TimeStep_dtRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dtRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_dtRatio_set) + +static bool js_TimeStep_dtRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dtRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_dtRatio_get) + +static bool js_TimeStep_velocityIterations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->velocityIterations, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_velocityIterations_set) + +static bool js_TimeStep_velocityIterations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->velocityIterations, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->velocityIterations, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_velocityIterations_get) + +static bool js_TimeStep_positionIterations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positionIterations, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_positionIterations_set) + +static bool js_TimeStep_positionIterations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positionIterations, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positionIterations, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_positionIterations_get) + +static bool js_TimeStep_warmStarting_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->warmStarting); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_TimeStep_warmStarting_set) + +static bool js_TimeStep_warmStarting_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2TimeStep *arg1 = (b2TimeStep *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->warmStarting, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_TimeStep_warmStarting_get) + +static bool js_new_b2TimeStep(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2TimeStep *result; + result = (b2TimeStep *)new b2TimeStep(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2TimeStep, __jsb_b2TimeStep_class, js_delete_b2TimeStep) + +static bool js_delete_b2TimeStep(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2TimeStep) + +template<> +bool sevalue_to_native(const se::Value &from, b2TimeStep * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("dt", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dt), ctx); + } + + + json->getProperty("inv_dt", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->inv_dt), ctx); + } + + + json->getProperty("dtRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dtRatio), ctx); + } + + + json->getProperty("velocityIterations", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->velocityIterations), ctx); + } + + + json->getProperty("positionIterations", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positionIterations), ctx); + } + + + json->getProperty("warmStarting", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->warmStarting), ctx); + } + + + return ok; +} + + +bool js_register_b2TimeStep(se::Object* obj) { + auto* cls = se::Class::create("TimeStep", obj, nullptr, _SE(js_new_b2TimeStep)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dt", _SE(js_TimeStep_dt_get), _SE(js_TimeStep_dt_set)); + cls->defineProperty("inv_dt", _SE(js_TimeStep_inv_dt_get), _SE(js_TimeStep_inv_dt_set)); + cls->defineProperty("dtRatio", _SE(js_TimeStep_dtRatio_get), _SE(js_TimeStep_dtRatio_set)); + cls->defineProperty("velocityIterations", _SE(js_TimeStep_velocityIterations_get), _SE(js_TimeStep_velocityIterations_set)); + cls->defineProperty("positionIterations", _SE(js_TimeStep_positionIterations_get), _SE(js_TimeStep_positionIterations_set)); + cls->defineProperty("warmStarting", _SE(js_TimeStep_warmStarting_get), _SE(js_TimeStep_warmStarting_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2TimeStep)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2TimeStep_proto = cls->getProto(); + __jsb_b2TimeStep_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Position_class = nullptr; +se::Object* __jsb_b2Position_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Position) + +static bool js_Position_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Position_c_set) + +static bool js_Position_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Position_c_get) + +static bool js_Position_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Position_a_set) + +static bool js_Position_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Position *arg1 = (b2Position *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Position_a_get) + +static bool js_new_b2Position(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Position *result; + result = (b2Position *)new b2Position(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Position, __jsb_b2Position_class, js_delete_b2Position) + +static bool js_delete_b2Position(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Position) + +template<> +bool sevalue_to_native(const se::Value &from, b2Position * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("c", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->c), ctx); + } + + + json->getProperty("a", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->a), ctx); + } + + + return ok; +} + + +bool js_register_b2Position(se::Object* obj) { + auto* cls = se::Class::create("Position", obj, nullptr, _SE(js_new_b2Position)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("c", _SE(js_Position_c_get), _SE(js_Position_c_set)); + cls->defineProperty("a", _SE(js_Position_a_get), _SE(js_Position_a_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Position)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Position_proto = cls->getProto(); + __jsb_b2Position_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2Velocity_class = nullptr; +se::Object* __jsb_b2Velocity_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2Velocity) + +static bool js_Velocity_v_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_Velocity_v_set) + +static bool js_Velocity_v_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->v, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_Velocity_v_get) + +static bool js_Velocity_w_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->w, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_Velocity_w_set) + +static bool js_Velocity_w_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2Velocity *arg1 = (b2Velocity *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->w, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_Velocity_w_get) + +static bool js_new_b2Velocity(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2Velocity *result; + result = (b2Velocity *)new b2Velocity(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2Velocity, __jsb_b2Velocity_class, js_delete_b2Velocity) + +static bool js_delete_b2Velocity(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2Velocity) + +template<> +bool sevalue_to_native(const se::Value &from, b2Velocity * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("v", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->v), ctx); + } + + + json->getProperty("w", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->w), ctx); + } + + + return ok; +} + + +bool js_register_b2Velocity(se::Object* obj) { + auto* cls = se::Class::create("Velocity", obj, nullptr, _SE(js_new_b2Velocity)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("v", _SE(js_Velocity_v_get), _SE(js_Velocity_v_set)); + cls->defineProperty("w", _SE(js_Velocity_w_get), _SE(js_Velocity_w_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2Velocity)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2Velocity_proto = cls->getProto(); + __jsb_b2Velocity_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2SolverData_class = nullptr; +se::Object* __jsb_b2SolverData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2SolverData) + +static bool js_SolverData_step_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->step, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_SolverData_step_set) + +static bool js_SolverData_step_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->step, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->step, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_SolverData_step_get) + +static bool js_SolverData_positions_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->positions, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_SolverData_positions_set) + +static bool js_SolverData_positions_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->positions, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->positions, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_SolverData_positions_get) + +static bool js_SolverData_velocities_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->velocities, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_SolverData_velocities_set) + +static bool js_SolverData_velocities_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2SolverData *arg1 = (b2SolverData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->velocities, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->velocities, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_SolverData_velocities_get) + +static bool js_new_b2SolverData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2SolverData *result; + result = (b2SolverData *)new b2SolverData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2SolverData, __jsb_b2SolverData_class, js_delete_b2SolverData) + +static bool js_delete_b2SolverData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2SolverData) + +template<> +bool sevalue_to_native(const se::Value &from, b2SolverData * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("step", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->step), ctx); + } + + + json->getProperty("positions", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->positions), ctx); + } + + + json->getProperty("velocities", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->velocities), ctx); + } + + + return ok; +} + + +bool js_register_b2SolverData(se::Object* obj) { + auto* cls = se::Class::create("SolverData", obj, nullptr, _SE(js_new_b2SolverData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("step", _SE(js_SolverData_step_get), _SE(js_SolverData_step_set)); + cls->defineProperty("positions", _SE(js_SolverData_positions_get), _SE(js_SolverData_positions_set)); + cls->defineProperty("velocities", _SE(js_SolverData_velocities_get), _SE(js_SolverData_velocities_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2SolverData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2SolverData_proto = cls->getProto(); + __jsb_b2SolverData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2World_class = nullptr; +se::Object* __jsb_b2World_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2World) + +static bool js_new_b2World(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + b2Vec2 *arg1 = 0 ; + b2Vec2 temp1 ; + b2World *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (b2World *)new b2World((b2Vec2 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2World, __jsb_b2World_class, js_delete_b2World) + +static bool js_delete_b2World(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2World) + +static bool js_World_SetDestructionListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2DestructionListener *arg2 = (b2DestructionListener *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDestructionListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetDestructionListener) + +static bool js_World_SetContactFilter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2ContactFilter *arg2 = (b2ContactFilter *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetContactFilter(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetContactFilter) + +static bool js_World_CreateBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2BodyDef *arg2 = (b2BodyDef *) NULL ; + b2Body *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Body *)(arg1)->CreateBody((b2BodyDef 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_World_CreateBody) + +static bool js_World_DestroyBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->DestroyBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_DestroyBody) + +static bool js_World_CreateJoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2JointDef *arg2 = (b2JointDef *) NULL ; + b2Joint *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (b2Joint *)(arg1)->CreateJoint((b2JointDef 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_World_CreateJoint) + +static bool js_World_DestroyJoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Joint *arg2 = (b2Joint *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->DestroyJoint(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_DestroyJoint) + +static bool js_World_Step(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + float arg2 ; + int32 arg3 ; + int32 arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Step(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_World_Step) + +static bool js_World_ClearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->ClearForces(); + + + return true; +} +SE_BIND_FUNC(js_World_ClearForces) + +static bool js_World_DrawDebugData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->DebugDraw(); + + + return true; +} +SE_BIND_FUNC(js_World_DrawDebugData) + +static bool js_World_GetBodyList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)(arg1)->GetBodyList(); + + 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_World_GetBodyList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Body *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Body *)((b2World const *)arg1)->GetBodyList(); + + 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_World_GetBodyList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_World_GetBodyList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_World_GetBodyList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_World_GetBodyList) + +static bool js_World_GetJointList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetJointList(); + + 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_World_GetJointList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Joint *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Joint *)((b2World const *)arg1)->GetJointList(); + + 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_World_GetJointList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_World_GetJointList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_World_GetJointList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_World_GetJointList) + +static bool js_World_GetContactList__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)(arg1)->GetContactList(); + + 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_World_GetContactList__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2World *arg1 = (b2World *) NULL ; + b2Contact *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (b2Contact *)((b2World const *)arg1)->GetContactList(); + + 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_World_GetContactList(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_World_GetContactList__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_World_GetContactList__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_World_GetContactList) + +static bool js_World_SetAllowSleeping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAllowSleeping(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetAllowSleeping) + +static bool js_World_GetAllowSleeping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetAllowSleeping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetAllowSleeping) + +static bool js_World_SetWarmStarting(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetWarmStarting(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetWarmStarting) + +static bool js_World_GetWarmStarting(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetWarmStarting(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetWarmStarting) + +static bool js_World_SetContinuousPhysics(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetContinuousPhysics(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetContinuousPhysics) + +static bool js_World_GetContinuousPhysics(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetContinuousPhysics(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetContinuousPhysics) + +static bool js_World_SetSubStepping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSubStepping(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetSubStepping) + +static bool js_World_GetSubStepping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetSubStepping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetSubStepping) + +static bool js_World_GetProxyCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetProxyCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetProxyCount) + +static bool js_World_GetBodyCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetBodyCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetBodyCount) + +static bool js_World_GetJointCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetJointCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetJointCount) + +static bool js_World_GetContactCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetContactCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetContactCount) + +static bool js_World_GetTreeHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetTreeHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetTreeHeight) + +static bool js_World_GetTreeBalance(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + int32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetTreeBalance(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetTreeBalance) + +static bool js_World_GetTreeQuality(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2World const *)arg1)->GetTreeQuality(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetTreeQuality) + +static bool js_World_SetGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetGravity((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetGravity) + +static bool js_World_GetGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2World const *)arg1)->GetGravity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_World_GetGravity) + +static bool js_World_IsLocked(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->IsLocked(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_IsLocked) + +static bool js_World_SetAutoClearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAutoClearForces(arg2); + + + return true; +} +SE_BIND_FUNC(js_World_SetAutoClearForces) + +static bool js_World_GetAutoClearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2World const *)arg1)->GetAutoClearForces(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_World_GetAutoClearForces) + +static bool js_World_ShiftOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->ShiftOrigin((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_World_ShiftOrigin) + +static bool js_World_GetContactManager(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2ContactManager *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(s); + if (nullptr == arg1) return true; + result = (b2ContactManager *) &((b2World const *)arg1)->GetContactManager(); + + 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_World_GetContactManager) + +static bool js_World_GetProfile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + b2Profile *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(s); + if (nullptr == arg1) return true; + result = (b2Profile *) &((b2World const *)arg1)->GetProfile(); + + 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_World_GetProfile) + +static bool js_World_Dump(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2World *arg1 = (b2World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->Dump(); + + + return true; +} +SE_BIND_FUNC(js_World_Dump) + +bool js_register_b2World(se::Object* obj) { + auto* cls = se::Class::create("World", obj, nullptr, _SE(js_new_b2World)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SetDestructionListener", _SE(js_World_SetDestructionListener)); + cls->defineFunction("SetContactFilter", _SE(js_World_SetContactFilter)); + cls->defineFunction("CreateBody", _SE(js_World_CreateBody)); + cls->defineFunction("DestroyBody", _SE(js_World_DestroyBody)); + cls->defineFunction("CreateJoint", _SE(js_World_CreateJoint)); + cls->defineFunction("DestroyJoint", _SE(js_World_DestroyJoint)); + cls->defineFunction("Step", _SE(js_World_Step)); + cls->defineFunction("ClearForces", _SE(js_World_ClearForces)); + cls->defineFunction("DrawDebugData", _SE(js_World_DrawDebugData)); + cls->defineFunction("GetBodyList", _SE(js_World_GetBodyList)); + cls->defineFunction("GetJointList", _SE(js_World_GetJointList)); + cls->defineFunction("GetContactList", _SE(js_World_GetContactList)); + cls->defineFunction("SetAllowSleeping", _SE(js_World_SetAllowSleeping)); + cls->defineFunction("GetAllowSleeping", _SE(js_World_GetAllowSleeping)); + cls->defineFunction("SetWarmStarting", _SE(js_World_SetWarmStarting)); + cls->defineFunction("GetWarmStarting", _SE(js_World_GetWarmStarting)); + cls->defineFunction("SetContinuousPhysics", _SE(js_World_SetContinuousPhysics)); + cls->defineFunction("GetContinuousPhysics", _SE(js_World_GetContinuousPhysics)); + cls->defineFunction("SetSubStepping", _SE(js_World_SetSubStepping)); + cls->defineFunction("GetSubStepping", _SE(js_World_GetSubStepping)); + cls->defineFunction("GetProxyCount", _SE(js_World_GetProxyCount)); + cls->defineFunction("GetBodyCount", _SE(js_World_GetBodyCount)); + cls->defineFunction("GetJointCount", _SE(js_World_GetJointCount)); + cls->defineFunction("GetContactCount", _SE(js_World_GetContactCount)); + cls->defineFunction("GetTreeHeight", _SE(js_World_GetTreeHeight)); + cls->defineFunction("GetTreeBalance", _SE(js_World_GetTreeBalance)); + cls->defineFunction("GetTreeQuality", _SE(js_World_GetTreeQuality)); + cls->defineFunction("SetGravity", _SE(js_World_SetGravity)); + cls->defineFunction("GetGravity", _SE(js_World_GetGravity)); + cls->defineFunction("IsLocked", _SE(js_World_IsLocked)); + cls->defineFunction("SetAutoClearForces", _SE(js_World_SetAutoClearForces)); + cls->defineFunction("GetAutoClearForces", _SE(js_World_GetAutoClearForces)); + cls->defineFunction("ShiftOrigin", _SE(js_World_ShiftOrigin)); + cls->defineFunction("GetContactManager", _SE(js_World_GetContactManager)); + cls->defineFunction("GetProfile", _SE(js_World_GetProfile)); + cls->defineFunction("Dump", _SE(js_World_Dump)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2World)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2World_proto = cls->getProto(); + __jsb_b2World_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DestructionListener_class = nullptr; +se::Object* __jsb_b2DestructionListener_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DestructionListener) + +static bool js_delete_b2DestructionListener(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DestructionListener) + +static bool js_DestructionListener_SayGoodbye__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2DestructionListener *arg1 = (b2DestructionListener *) NULL ; + b2Joint *arg2 = (b2Joint *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SayGoodbye(arg2); + + + return true; +} + +static bool js_DestructionListener_SayGoodbye__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + b2DestructionListener *arg1 = (b2DestructionListener *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SayGoodbye(arg2); + + + return true; +} + +static bool js_DestructionListener_SayGoodbye(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_DestructionListener_SayGoodbye__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_DestructionListener_SayGoodbye__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_DestructionListener_SayGoodbye) + +bool js_register_b2DestructionListener(se::Object* obj) { + auto* cls = se::Class::create("DestructionListener", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SayGoodbye", _SE(js_DestructionListener_SayGoodbye)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DestructionListener)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DestructionListener_proto = cls->getProto(); + __jsb_b2DestructionListener_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactFilter_class = nullptr; +se::Object* __jsb_b2ContactFilter_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactFilter) + +static bool js_delete_b2ContactFilter(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactFilter) + +static bool js_ContactFilter_ShouldCollide(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactFilter *arg1 = (b2ContactFilter *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + b2Fixture *arg3 = (b2Fixture *) NULL ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->ShouldCollide(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_ContactFilter_ShouldCollide) + +static bool js_new_b2ContactFilter(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactFilter *result; + result = (b2ContactFilter *)new b2ContactFilter(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactFilter, __jsb_b2ContactFilter_class, js_delete_b2ContactFilter) + +bool js_register_b2ContactFilter(se::Object* obj) { + auto* cls = se::Class::create("ContactFilter", obj, nullptr, _SE(js_new_b2ContactFilter)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("ShouldCollide", _SE(js_ContactFilter_ShouldCollide)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactFilter)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactFilter_proto = cls->getProto(); + __jsb_b2ContactFilter_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2ContactImpulse_class = nullptr; +se::Object* __jsb_b2ContactImpulse_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2ContactImpulse) + +static bool js_ContactImpulse_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2ContactImpulse *arg1 = (b2ContactImpulse *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_ContactImpulse_count_set) + +static bool js_ContactImpulse_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2ContactImpulse *arg1 = (b2ContactImpulse *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->count, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_ContactImpulse_count_get) + +static bool js_new_b2ContactImpulse(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2ContactImpulse *result; + result = (b2ContactImpulse *)new b2ContactImpulse(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2ContactImpulse, __jsb_b2ContactImpulse_class, js_delete_b2ContactImpulse) + +static bool js_delete_b2ContactImpulse(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2ContactImpulse) + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactImpulse * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + return ok; +} + + +bool js_register_b2ContactImpulse(se::Object* obj) { + auto* cls = se::Class::create("ContactImpulse", obj, nullptr, _SE(js_new_b2ContactImpulse)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("count", _SE(js_ContactImpulse_count_get), _SE(js_ContactImpulse_count_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2ContactImpulse)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2ContactImpulse_proto = cls->getProto(); + __jsb_b2ContactImpulse_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RopeJointDef_class = nullptr; +se::Object* __jsb_b2RopeJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RopeJointDef) + +static bool js_new_b2RopeJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RopeJointDef *result; + result = (b2RopeJointDef *)new b2RopeJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RopeJointDef, __jsb_b2RopeJointDef_class, js_delete_b2RopeJointDef) + +static bool js_RopeJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RopeJointDef_localAnchorA_set) + +static bool js_RopeJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RopeJointDef_localAnchorA_get) + +static bool js_RopeJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RopeJointDef_localAnchorB_set) + +static bool js_RopeJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RopeJointDef_localAnchorB_get) + +static bool js_RopeJointDef_maxLength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxLength, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RopeJointDef_maxLength_set) + +static bool js_RopeJointDef_maxLength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RopeJointDef *arg1 = (b2RopeJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxLength, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RopeJointDef_maxLength_get) + +static bool js_delete_b2RopeJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RopeJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2RopeJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("maxLength", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxLength), ctx); + } + + + return ok; +} + + +bool js_register_b2RopeJointDef(se::Object* obj) { + auto* cls = se::Class::create("RopeJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2RopeJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_RopeJointDef_localAnchorA_get), _SE(js_RopeJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_RopeJointDef_localAnchorB_get), _SE(js_RopeJointDef_localAnchorB_set)); + cls->defineProperty("maxLength", _SE(js_RopeJointDef_maxLength_get), _SE(js_RopeJointDef_maxLength_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RopeJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RopeJointDef_proto = cls->getProto(); + __jsb_b2RopeJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RopeJoint_class = nullptr; +se::Object* __jsb_b2RopeJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RopeJoint) + +static bool js_RopeJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RopeJoint const *)arg1)->GetLocalAnchorA(); + + 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_RopeJoint_GetLocalAnchorA) + +static bool js_RopeJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RopeJoint const *)arg1)->GetLocalAnchorB(); + + 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_RopeJoint_GetLocalAnchorB) + +static bool js_RopeJoint_SetMaxLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxLength(arg2); + + + return true; +} +SE_BIND_FUNC(js_RopeJoint_SetMaxLength) + +static bool js_RopeJoint_GetMaxLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RopeJoint const *)arg1)->GetMaxLength(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RopeJoint_GetMaxLength) + +static bool js_RopeJoint_GetLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RopeJoint *arg1 = (b2RopeJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RopeJoint const *)arg1)->GetLength(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RopeJoint_GetLength) + +static bool js_delete_b2RopeJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RopeJoint) + +bool js_register_b2RopeJoint(se::Object* obj) { + auto* cls = se::Class::create("RopeJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_RopeJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_RopeJoint_GetLocalAnchorB)); + cls->defineFunction("SetMaxLength", _SE(js_RopeJoint_SetMaxLength)); + cls->defineFunction("GetMaxLength", _SE(js_RopeJoint_GetMaxLength)); + cls->defineFunction("GetLength", _SE(js_RopeJoint_GetLength)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RopeJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RopeJoint_proto = cls->getProto(); + __jsb_b2RopeJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FrictionJointDef_class = nullptr; +se::Object* __jsb_b2FrictionJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FrictionJointDef) + +static bool js_new_b2FrictionJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2FrictionJointDef *result; + result = (b2FrictionJointDef *)new b2FrictionJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2FrictionJointDef, __jsb_b2FrictionJointDef_class, js_delete_b2FrictionJointDef) + +static bool js_FrictionJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_FrictionJointDef_Initialize) + +static bool js_FrictionJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_localAnchorA_set) + +static bool js_FrictionJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_localAnchorA_get) + +static bool js_FrictionJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_localAnchorB_set) + +static bool js_FrictionJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_localAnchorB_get) + +static bool js_FrictionJointDef_maxForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_maxForce_set) + +static bool js_FrictionJointDef_maxForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_maxForce_get) + +static bool js_FrictionJointDef_maxTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_FrictionJointDef_maxTorque_set) + +static bool js_FrictionJointDef_maxTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2FrictionJointDef *arg1 = (b2FrictionJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_FrictionJointDef_maxTorque_get) + +static bool js_delete_b2FrictionJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FrictionJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2FrictionJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("maxForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxForce), ctx); + } + + + json->getProperty("maxTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTorque), ctx); + } + + + return ok; +} + + +bool js_register_b2FrictionJointDef(se::Object* obj) { + auto* cls = se::Class::create("FrictionJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2FrictionJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_FrictionJointDef_localAnchorA_get), _SE(js_FrictionJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_FrictionJointDef_localAnchorB_get), _SE(js_FrictionJointDef_localAnchorB_set)); + cls->defineProperty("maxForce", _SE(js_FrictionJointDef_maxForce_get), _SE(js_FrictionJointDef_maxForce_set)); + cls->defineProperty("maxTorque", _SE(js_FrictionJointDef_maxTorque_get), _SE(js_FrictionJointDef_maxTorque_set)); + + cls->defineFunction("Initialize", _SE(js_FrictionJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FrictionJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FrictionJointDef_proto = cls->getProto(); + __jsb_b2FrictionJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2FrictionJoint_class = nullptr; +se::Object* __jsb_b2FrictionJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2FrictionJoint) + +static bool js_FrictionJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2FrictionJoint const *)arg1)->GetLocalAnchorA(); + + 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_FrictionJoint_GetLocalAnchorA) + +static bool js_FrictionJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2FrictionJoint const *)arg1)->GetLocalAnchorB(); + + 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_FrictionJoint_GetLocalAnchorB) + +static bool js_FrictionJoint_SetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_SetMaxForce) + +static bool js_FrictionJoint_GetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2FrictionJoint const *)arg1)->GetMaxForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_GetMaxForce) + +static bool js_FrictionJoint_SetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_SetMaxTorque) + +static bool js_FrictionJoint_GetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2FrictionJoint *arg1 = (b2FrictionJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2FrictionJoint const *)arg1)->GetMaxTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_FrictionJoint_GetMaxTorque) + +static bool js_delete_b2FrictionJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2FrictionJoint) + +bool js_register_b2FrictionJoint(se::Object* obj) { + auto* cls = se::Class::create("FrictionJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_FrictionJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_FrictionJoint_GetLocalAnchorB)); + cls->defineFunction("SetMaxForce", _SE(js_FrictionJoint_SetMaxForce)); + cls->defineFunction("GetMaxForce", _SE(js_FrictionJoint_GetMaxForce)); + cls->defineFunction("SetMaxTorque", _SE(js_FrictionJoint_SetMaxTorque)); + cls->defineFunction("GetMaxTorque", _SE(js_FrictionJoint_GetMaxTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2FrictionJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2FrictionJoint_proto = cls->getProto(); + __jsb_b2FrictionJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DistanceJointDef_class = nullptr; +se::Object* __jsb_b2DistanceJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DistanceJointDef) + +static bool js_new_b2DistanceJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2DistanceJointDef *result; + result = (b2DistanceJointDef *)new b2DistanceJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2DistanceJointDef, __jsb_b2DistanceJointDef_class, js_delete_b2DistanceJointDef) + +static bool js_DistanceJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_DistanceJointDef_Initialize) + +static bool js_DistanceJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_localAnchorA_set) + +static bool js_DistanceJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_localAnchorA_get) + +static bool js_DistanceJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_localAnchorB_set) + +static bool js_DistanceJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_localAnchorB_get) + +static bool js_DistanceJointDef_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->length, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_length_set) + +static bool js_DistanceJointDef_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->length, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_length_get) + +static bool js_DistanceJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_frequencyHz_set) + +static bool js_DistanceJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_frequencyHz_get) + +static bool js_DistanceJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_DistanceJointDef_dampingRatio_set) + +static bool js_DistanceJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2DistanceJointDef *arg1 = (b2DistanceJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_DistanceJointDef_dampingRatio_get) + +static bool js_delete_b2DistanceJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DistanceJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2DistanceJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("length", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->length), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2DistanceJointDef(se::Object* obj) { + auto* cls = se::Class::create("DistanceJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2DistanceJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_DistanceJointDef_localAnchorA_get), _SE(js_DistanceJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_DistanceJointDef_localAnchorB_get), _SE(js_DistanceJointDef_localAnchorB_set)); + cls->defineProperty("length", _SE(js_DistanceJointDef_length_get), _SE(js_DistanceJointDef_length_set)); + cls->defineProperty("frequencyHz", _SE(js_DistanceJointDef_frequencyHz_get), _SE(js_DistanceJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_DistanceJointDef_dampingRatio_get), _SE(js_DistanceJointDef_dampingRatio_set)); + + cls->defineFunction("Initialize", _SE(js_DistanceJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DistanceJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DistanceJointDef_proto = cls->getProto(); + __jsb_b2DistanceJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2DistanceJoint_class = nullptr; +se::Object* __jsb_b2DistanceJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2DistanceJoint) + +static bool js_DistanceJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2DistanceJoint const *)arg1)->GetLocalAnchorA(); + + 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_DistanceJoint_GetLocalAnchorA) + +static bool js_DistanceJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2DistanceJoint const *)arg1)->GetLocalAnchorB(); + + 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_DistanceJoint_GetLocalAnchorB) + +static bool js_DistanceJoint_SetLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetLength(arg2); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_SetLength) + +static bool js_DistanceJoint_GetLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DistanceJoint const *)arg1)->GetLength(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_GetLength) + +static bool js_DistanceJoint_SetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFrequency(arg2); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_SetFrequency) + +static bool js_DistanceJoint_GetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DistanceJoint const *)arg1)->GetFrequency(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_GetFrequency) + +static bool js_DistanceJoint_SetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_SetDampingRatio) + +static bool js_DistanceJoint_GetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2DistanceJoint *arg1 = (b2DistanceJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2DistanceJoint const *)arg1)->GetDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_DistanceJoint_GetDampingRatio) + +static bool js_delete_b2DistanceJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2DistanceJoint) + +bool js_register_b2DistanceJoint(se::Object* obj) { + auto* cls = se::Class::create("DistanceJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_DistanceJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_DistanceJoint_GetLocalAnchorB)); + cls->defineFunction("SetLength", _SE(js_DistanceJoint_SetLength)); + cls->defineFunction("GetLength", _SE(js_DistanceJoint_GetLength)); + cls->defineFunction("SetFrequency", _SE(js_DistanceJoint_SetFrequency)); + cls->defineFunction("GetFrequency", _SE(js_DistanceJoint_GetFrequency)); + cls->defineFunction("SetDampingRatio", _SE(js_DistanceJoint_SetDampingRatio)); + cls->defineFunction("GetDampingRatio", _SE(js_DistanceJoint_GetDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2DistanceJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2DistanceJoint_proto = cls->getProto(); + __jsb_b2DistanceJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2GearJointDef_class = nullptr; +se::Object* __jsb_b2GearJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2GearJointDef) + +static bool js_new_b2GearJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2GearJointDef *result; + result = (b2GearJointDef *)new b2GearJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2GearJointDef, __jsb_b2GearJointDef_class, js_delete_b2GearJointDef) + +static bool js_GearJointDef_joint1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->joint1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_GearJointDef_joint1_set) + +static bool js_GearJointDef_joint1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->joint1, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->joint1, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_GearJointDef_joint1_get) + +static bool js_GearJointDef_joint2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->joint2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_GearJointDef_joint2_set) + +static bool js_GearJointDef_joint2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->joint2, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->joint2, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_GearJointDef_joint2_get) + +static bool js_GearJointDef_ratio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ratio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_GearJointDef_ratio_set) + +static bool js_GearJointDef_ratio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2GearJointDef *arg1 = (b2GearJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ratio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_GearJointDef_ratio_get) + +static bool js_delete_b2GearJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2GearJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2GearJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("joint1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->joint1), ctx); + } + + + json->getProperty("joint2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->joint2), ctx); + } + + + json->getProperty("ratio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ratio), ctx); + } + + + return ok; +} + + +bool js_register_b2GearJointDef(se::Object* obj) { + auto* cls = se::Class::create("GearJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2GearJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("joint1", _SE(js_GearJointDef_joint1_get), _SE(js_GearJointDef_joint1_set)); + cls->defineProperty("joint2", _SE(js_GearJointDef_joint2_get), _SE(js_GearJointDef_joint2_set)); + cls->defineProperty("ratio", _SE(js_GearJointDef_ratio_get), _SE(js_GearJointDef_ratio_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2GearJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2GearJointDef_proto = cls->getProto(); + __jsb_b2GearJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2GearJoint_class = nullptr; +se::Object* __jsb_b2GearJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2GearJoint) + +static bool js_GearJoint_GetJoint1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + b2Joint *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(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetJoint1(); + + 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_GearJoint_GetJoint1) + +static bool js_GearJoint_GetJoint2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + b2Joint *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(s); + if (nullptr == arg1) return true; + result = (b2Joint *)(arg1)->GetJoint2(); + + 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_GearJoint_GetJoint2) + +static bool js_GearJoint_SetRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_GearJoint_SetRatio) + +static bool js_GearJoint_GetRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2GearJoint *arg1 = (b2GearJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2GearJoint const *)arg1)->GetRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_GearJoint_GetRatio) + +static bool js_delete_b2GearJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2GearJoint) + +bool js_register_b2GearJoint(se::Object* obj) { + auto* cls = se::Class::create("GearJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetJoint1", _SE(js_GearJoint_GetJoint1)); + cls->defineFunction("GetJoint2", _SE(js_GearJoint_GetJoint2)); + cls->defineFunction("SetRatio", _SE(js_GearJoint_SetRatio)); + cls->defineFunction("GetRatio", _SE(js_GearJoint_GetRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2GearJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2GearJoint_proto = cls->getProto(); + __jsb_b2GearJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MotorJointDef_class = nullptr; +se::Object* __jsb_b2MotorJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MotorJointDef) + +static bool js_new_b2MotorJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2MotorJointDef *result; + result = (b2MotorJointDef *)new b2MotorJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2MotorJointDef, __jsb_b2MotorJointDef_class, js_delete_b2MotorJointDef) + +static bool js_MotorJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->Initialize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_MotorJointDef_Initialize) + +static bool js_MotorJointDef_linearOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->linearOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_linearOffset_set) + +static bool js_MotorJointDef_linearOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->linearOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->linearOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_linearOffset_get) + +static bool js_MotorJointDef_angularOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->angularOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_angularOffset_set) + +static bool js_MotorJointDef_angularOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->angularOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_angularOffset_get) + +static bool js_MotorJointDef_maxForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_maxForce_set) + +static bool js_MotorJointDef_maxForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_maxForce_get) + +static bool js_MotorJointDef_maxTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_maxTorque_set) + +static bool js_MotorJointDef_maxTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_maxTorque_get) + +static bool js_MotorJointDef_correctionFactor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->correctionFactor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MotorJointDef_correctionFactor_set) + +static bool js_MotorJointDef_correctionFactor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MotorJointDef *arg1 = (b2MotorJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->correctionFactor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MotorJointDef_correctionFactor_get) + +static bool js_delete_b2MotorJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MotorJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2MotorJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("linearOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->linearOffset), ctx); + } + + + json->getProperty("angularOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->angularOffset), ctx); + } + + + json->getProperty("maxForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxForce), ctx); + } + + + json->getProperty("maxTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTorque), ctx); + } + + + json->getProperty("correctionFactor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->correctionFactor), ctx); + } + + + return ok; +} + + +bool js_register_b2MotorJointDef(se::Object* obj) { + auto* cls = se::Class::create("MotorJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2MotorJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("linearOffset", _SE(js_MotorJointDef_linearOffset_get), _SE(js_MotorJointDef_linearOffset_set)); + cls->defineProperty("angularOffset", _SE(js_MotorJointDef_angularOffset_get), _SE(js_MotorJointDef_angularOffset_set)); + cls->defineProperty("maxForce", _SE(js_MotorJointDef_maxForce_get), _SE(js_MotorJointDef_maxForce_set)); + cls->defineProperty("maxTorque", _SE(js_MotorJointDef_maxTorque_get), _SE(js_MotorJointDef_maxTorque_set)); + cls->defineProperty("correctionFactor", _SE(js_MotorJointDef_correctionFactor_get), _SE(js_MotorJointDef_correctionFactor_set)); + + cls->defineFunction("Initialize", _SE(js_MotorJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MotorJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MotorJointDef_proto = cls->getProto(); + __jsb_b2MotorJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MotorJoint_class = nullptr; +se::Object* __jsb_b2MotorJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MotorJoint) + +static bool js_MotorJoint_SetLinearOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLinearOffset((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetLinearOffset) + +static bool js_MotorJoint_GetLinearOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2MotorJoint const *)arg1)->GetLinearOffset(); + + 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_MotorJoint_GetLinearOffset) + +static bool js_MotorJoint_SetAngularOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetAngularOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetAngularOffset) + +static bool js_MotorJoint_GetAngularOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetAngularOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetAngularOffset) + +static bool js_MotorJoint_SetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetMaxForce) + +static bool js_MotorJoint_GetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetMaxForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetMaxForce) + +static bool js_MotorJoint_SetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetMaxTorque) + +static bool js_MotorJoint_GetMaxTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetMaxTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetMaxTorque) + +static bool js_MotorJoint_SetCorrectionFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetCorrectionFactor(arg2); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_SetCorrectionFactor) + +static bool js_MotorJoint_GetCorrectionFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MotorJoint *arg1 = (b2MotorJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MotorJoint const *)arg1)->GetCorrectionFactor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MotorJoint_GetCorrectionFactor) + +static bool js_delete_b2MotorJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MotorJoint) + +bool js_register_b2MotorJoint(se::Object* obj) { + auto* cls = se::Class::create("MotorJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SetLinearOffset", _SE(js_MotorJoint_SetLinearOffset)); + cls->defineFunction("GetLinearOffset", _SE(js_MotorJoint_GetLinearOffset)); + cls->defineFunction("SetAngularOffset", _SE(js_MotorJoint_SetAngularOffset)); + cls->defineFunction("GetAngularOffset", _SE(js_MotorJoint_GetAngularOffset)); + cls->defineFunction("SetMaxForce", _SE(js_MotorJoint_SetMaxForce)); + cls->defineFunction("GetMaxForce", _SE(js_MotorJoint_GetMaxForce)); + cls->defineFunction("SetMaxTorque", _SE(js_MotorJoint_SetMaxTorque)); + cls->defineFunction("GetMaxTorque", _SE(js_MotorJoint_GetMaxTorque)); + cls->defineFunction("SetCorrectionFactor", _SE(js_MotorJoint_SetCorrectionFactor)); + cls->defineFunction("GetCorrectionFactor", _SE(js_MotorJoint_GetCorrectionFactor)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MotorJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MotorJoint_proto = cls->getProto(); + __jsb_b2MotorJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MouseJointDef_class = nullptr; +se::Object* __jsb_b2MouseJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MouseJointDef) + +static bool js_new_b2MouseJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2MouseJointDef *result; + result = (b2MouseJointDef *)new b2MouseJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2MouseJointDef, __jsb_b2MouseJointDef_class, js_delete_b2MouseJointDef) + +static bool js_MouseJointDef_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->target, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_target_set) + +static bool js_MouseJointDef_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->target, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->target, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_target_get) + +static bool js_MouseJointDef_maxForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_maxForce_set) + +static bool js_MouseJointDef_maxForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_maxForce_get) + +static bool js_MouseJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_frequencyHz_set) + +static bool js_MouseJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_frequencyHz_get) + +static bool js_MouseJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_MouseJointDef_dampingRatio_set) + +static bool js_MouseJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2MouseJointDef *arg1 = (b2MouseJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_MouseJointDef_dampingRatio_get) + +static bool js_delete_b2MouseJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MouseJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2MouseJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("target", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->target), ctx); + } + + + json->getProperty("maxForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxForce), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2MouseJointDef(se::Object* obj) { + auto* cls = se::Class::create("MouseJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2MouseJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("target", _SE(js_MouseJointDef_target_get), _SE(js_MouseJointDef_target_set)); + cls->defineProperty("maxForce", _SE(js_MouseJointDef_maxForce_get), _SE(js_MouseJointDef_maxForce_set)); + cls->defineProperty("frequencyHz", _SE(js_MouseJointDef_frequencyHz_get), _SE(js_MouseJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_MouseJointDef_dampingRatio_get), _SE(js_MouseJointDef_dampingRatio_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MouseJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MouseJointDef_proto = cls->getProto(); + __jsb_b2MouseJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2MouseJoint_class = nullptr; +se::Object* __jsb_b2MouseJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2MouseJoint) + +static bool js_MouseJoint_SetTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetTarget((b2Vec2 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetTarget) + +static bool js_MouseJoint_GetTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2MouseJoint const *)arg1)->GetTarget(); + + 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_MouseJoint_GetTarget) + +static bool js_MouseJoint_SetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetMaxForce) + +static bool js_MouseJoint_GetMaxForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MouseJoint const *)arg1)->GetMaxForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_GetMaxForce) + +static bool js_MouseJoint_SetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFrequency(arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetFrequency) + +static bool js_MouseJoint_GetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MouseJoint const *)arg1)->GetFrequency(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_GetFrequency) + +static bool js_MouseJoint_SetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_SetDampingRatio) + +static bool js_MouseJoint_GetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2MouseJoint *arg1 = (b2MouseJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2MouseJoint const *)arg1)->GetDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_MouseJoint_GetDampingRatio) + +static bool js_delete_b2MouseJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2MouseJoint) + +bool js_register_b2MouseJoint(se::Object* obj) { + auto* cls = se::Class::create("MouseJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("SetTarget", _SE(js_MouseJoint_SetTarget)); + cls->defineFunction("GetTarget", _SE(js_MouseJoint_GetTarget)); + cls->defineFunction("SetMaxForce", _SE(js_MouseJoint_SetMaxForce)); + cls->defineFunction("GetMaxForce", _SE(js_MouseJoint_GetMaxForce)); + cls->defineFunction("SetFrequency", _SE(js_MouseJoint_SetFrequency)); + cls->defineFunction("GetFrequency", _SE(js_MouseJoint_GetFrequency)); + cls->defineFunction("SetDampingRatio", _SE(js_MouseJoint_SetDampingRatio)); + cls->defineFunction("GetDampingRatio", _SE(js_MouseJoint_GetDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2MouseJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2MouseJoint_proto = cls->getProto(); + __jsb_b2MouseJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PrismaticJointDef_class = nullptr; +se::Object* __jsb_b2PrismaticJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PrismaticJointDef) + +static bool js_new_b2PrismaticJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2PrismaticJointDef *result; + result = (b2PrismaticJointDef *)new b2PrismaticJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2PrismaticJointDef, __jsb_b2PrismaticJointDef_class, js_delete_b2PrismaticJointDef) + +static bool js_PrismaticJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJointDef_Initialize) + +static bool js_PrismaticJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_localAnchorA_set) + +static bool js_PrismaticJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_localAnchorA_get) + +static bool js_PrismaticJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_localAnchorB_set) + +static bool js_PrismaticJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_localAnchorB_get) + +static bool js_PrismaticJointDef_localAxisA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAxisA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_localAxisA_set) + +static bool js_PrismaticJointDef_localAxisA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAxisA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAxisA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_localAxisA_get) + +static bool js_PrismaticJointDef_referenceAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->referenceAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_referenceAngle_set) + +static bool js_PrismaticJointDef_referenceAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->referenceAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_referenceAngle_get) + +static bool js_PrismaticJointDef_enableLimit_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableLimit); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_enableLimit_set) + +static bool js_PrismaticJointDef_enableLimit_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableLimit, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_enableLimit_get) + +static bool js_PrismaticJointDef_lowerTranslation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lowerTranslation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_lowerTranslation_set) + +static bool js_PrismaticJointDef_lowerTranslation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lowerTranslation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_lowerTranslation_get) + +static bool js_PrismaticJointDef_upperTranslation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->upperTranslation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_upperTranslation_set) + +static bool js_PrismaticJointDef_upperTranslation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->upperTranslation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_upperTranslation_get) + +static bool js_PrismaticJointDef_enableMotor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableMotor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_enableMotor_set) + +static bool js_PrismaticJointDef_enableMotor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableMotor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_enableMotor_get) + +static bool js_PrismaticJointDef_maxMotorForce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxMotorForce, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_maxMotorForce_set) + +static bool js_PrismaticJointDef_maxMotorForce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxMotorForce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_maxMotorForce_get) + +static bool js_PrismaticJointDef_motorSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->motorSpeed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PrismaticJointDef_motorSpeed_set) + +static bool js_PrismaticJointDef_motorSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PrismaticJointDef *arg1 = (b2PrismaticJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->motorSpeed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PrismaticJointDef_motorSpeed_get) + +static bool js_delete_b2PrismaticJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PrismaticJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2PrismaticJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("localAxisA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAxisA), ctx); + } + + + json->getProperty("referenceAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->referenceAngle), ctx); + } + + + json->getProperty("enableLimit", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableLimit), ctx); + } + + + json->getProperty("lowerTranslation", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lowerTranslation), ctx); + } + + + json->getProperty("upperTranslation", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->upperTranslation), ctx); + } + + + json->getProperty("enableMotor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableMotor), ctx); + } + + + json->getProperty("maxMotorForce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxMotorForce), ctx); + } + + + json->getProperty("motorSpeed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->motorSpeed), ctx); + } + + + return ok; +} + + +bool js_register_b2PrismaticJointDef(se::Object* obj) { + auto* cls = se::Class::create("PrismaticJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2PrismaticJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_PrismaticJointDef_localAnchorA_get), _SE(js_PrismaticJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_PrismaticJointDef_localAnchorB_get), _SE(js_PrismaticJointDef_localAnchorB_set)); + cls->defineProperty("localAxisA", _SE(js_PrismaticJointDef_localAxisA_get), _SE(js_PrismaticJointDef_localAxisA_set)); + cls->defineProperty("referenceAngle", _SE(js_PrismaticJointDef_referenceAngle_get), _SE(js_PrismaticJointDef_referenceAngle_set)); + cls->defineProperty("enableLimit", _SE(js_PrismaticJointDef_enableLimit_get), _SE(js_PrismaticJointDef_enableLimit_set)); + cls->defineProperty("lowerTranslation", _SE(js_PrismaticJointDef_lowerTranslation_get), _SE(js_PrismaticJointDef_lowerTranslation_set)); + cls->defineProperty("upperTranslation", _SE(js_PrismaticJointDef_upperTranslation_get), _SE(js_PrismaticJointDef_upperTranslation_set)); + cls->defineProperty("enableMotor", _SE(js_PrismaticJointDef_enableMotor_get), _SE(js_PrismaticJointDef_enableMotor_set)); + cls->defineProperty("maxMotorForce", _SE(js_PrismaticJointDef_maxMotorForce_get), _SE(js_PrismaticJointDef_maxMotorForce_set)); + cls->defineProperty("motorSpeed", _SE(js_PrismaticJointDef_motorSpeed_get), _SE(js_PrismaticJointDef_motorSpeed_set)); + + cls->defineFunction("Initialize", _SE(js_PrismaticJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PrismaticJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PrismaticJointDef_proto = cls->getProto(); + __jsb_b2PrismaticJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PrismaticJoint_class = nullptr; +se::Object* __jsb_b2PrismaticJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PrismaticJoint) + +static bool js_PrismaticJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2PrismaticJoint const *)arg1)->GetLocalAnchorA(); + + 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_PrismaticJoint_GetLocalAnchorA) + +static bool js_PrismaticJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2PrismaticJoint const *)arg1)->GetLocalAnchorB(); + + 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_PrismaticJoint_GetLocalAnchorB) + +static bool js_PrismaticJoint_GetLocalAxisA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2PrismaticJoint const *)arg1)->GetLocalAxisA(); + + 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_PrismaticJoint_GetLocalAxisA) + +static bool js_PrismaticJoint_GetReferenceAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetReferenceAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetReferenceAngle) + +static bool js_PrismaticJoint_GetJointTranslation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetJointTranslation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetJointTranslation) + +static bool js_PrismaticJoint_GetJointSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetJointSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetJointSpeed) + +static bool js_PrismaticJoint_IsLimitEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2PrismaticJoint const *)arg1)->IsLimitEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_IsLimitEnabled) + +static bool js_PrismaticJoint_EnableLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_EnableLimit) + +static bool js_PrismaticJoint_GetLowerLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetLowerLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetLowerLimit) + +static bool js_PrismaticJoint_GetUpperLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetUpperLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetUpperLimit) + +static bool js_PrismaticJoint_SetLimits(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLimits(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_SetLimits) + +static bool js_PrismaticJoint_IsMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2PrismaticJoint const *)arg1)->IsMotorEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_IsMotorEnabled) + +static bool js_PrismaticJoint_EnableMotor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableMotor(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_EnableMotor) + +static bool js_PrismaticJoint_SetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMotorSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_SetMotorSpeed) + +static bool js_PrismaticJoint_GetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetMotorSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetMotorSpeed) + +static bool js_PrismaticJoint_SetMaxMotorForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxMotorForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_SetMaxMotorForce) + +static bool js_PrismaticJoint_GetMaxMotorForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PrismaticJoint const *)arg1)->GetMaxMotorForce(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetMaxMotorForce) + +static bool js_PrismaticJoint_GetMotorForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PrismaticJoint *arg1 = (b2PrismaticJoint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2PrismaticJoint const *)arg1)->GetMotorForce(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PrismaticJoint_GetMotorForce) + +static bool js_delete_b2PrismaticJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PrismaticJoint) + +bool js_register_b2PrismaticJoint(se::Object* obj) { + auto* cls = se::Class::create("PrismaticJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_PrismaticJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_PrismaticJoint_GetLocalAnchorB)); + cls->defineFunction("GetLocalAxisA", _SE(js_PrismaticJoint_GetLocalAxisA)); + cls->defineFunction("GetReferenceAngle", _SE(js_PrismaticJoint_GetReferenceAngle)); + cls->defineFunction("GetJointTranslation", _SE(js_PrismaticJoint_GetJointTranslation)); + cls->defineFunction("GetJointSpeed", _SE(js_PrismaticJoint_GetJointSpeed)); + cls->defineFunction("IsLimitEnabled", _SE(js_PrismaticJoint_IsLimitEnabled)); + cls->defineFunction("EnableLimit", _SE(js_PrismaticJoint_EnableLimit)); + cls->defineFunction("GetLowerLimit", _SE(js_PrismaticJoint_GetLowerLimit)); + cls->defineFunction("GetUpperLimit", _SE(js_PrismaticJoint_GetUpperLimit)); + cls->defineFunction("SetLimits", _SE(js_PrismaticJoint_SetLimits)); + cls->defineFunction("IsMotorEnabled", _SE(js_PrismaticJoint_IsMotorEnabled)); + cls->defineFunction("EnableMotor", _SE(js_PrismaticJoint_EnableMotor)); + cls->defineFunction("SetMotorSpeed", _SE(js_PrismaticJoint_SetMotorSpeed)); + cls->defineFunction("GetMotorSpeed", _SE(js_PrismaticJoint_GetMotorSpeed)); + cls->defineFunction("SetMaxMotorForce", _SE(js_PrismaticJoint_SetMaxMotorForce)); + cls->defineFunction("GetMaxMotorForce", _SE(js_PrismaticJoint_GetMaxMotorForce)); + cls->defineFunction("GetMotorForce", _SE(js_PrismaticJoint_GetMotorForce)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PrismaticJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PrismaticJoint_proto = cls->getProto(); + __jsb_b2PrismaticJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PulleyJointDef_class = nullptr; +se::Object* __jsb_b2PulleyJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PulleyJointDef) + +static bool js_new_b2PulleyJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2PulleyJointDef *result; + result = (b2PulleyJointDef *)new b2PulleyJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2PulleyJointDef, __jsb_b2PulleyJointDef_class, js_delete_b2PulleyJointDef) + +static bool js_PulleyJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 *arg6 = 0 ; + b2Vec2 *arg7 = 0 ; + float arg8 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + b2Vec2 temp6 ; + b2Vec2 temp7 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5,(b2Vec2 const &)*arg6,(b2Vec2 const &)*arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_PulleyJointDef_Initialize) + +static bool js_PulleyJointDef_groundAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groundAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_groundAnchorA_set) + +static bool js_PulleyJointDef_groundAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groundAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->groundAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_groundAnchorA_get) + +static bool js_PulleyJointDef_groundAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groundAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_groundAnchorB_set) + +static bool js_PulleyJointDef_groundAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groundAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->groundAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_groundAnchorB_get) + +static bool js_PulleyJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_localAnchorA_set) + +static bool js_PulleyJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_localAnchorA_get) + +static bool js_PulleyJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_localAnchorB_set) + +static bool js_PulleyJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_localAnchorB_get) + +static bool js_PulleyJointDef_lengthA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lengthA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_lengthA_set) + +static bool js_PulleyJointDef_lengthA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lengthA, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_lengthA_get) + +static bool js_PulleyJointDef_lengthB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lengthB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_lengthB_set) + +static bool js_PulleyJointDef_lengthB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lengthB, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_lengthB_get) + +static bool js_PulleyJointDef_ratio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ratio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_PulleyJointDef_ratio_set) + +static bool js_PulleyJointDef_ratio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2PulleyJointDef *arg1 = (b2PulleyJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ratio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_PulleyJointDef_ratio_get) + +static bool js_delete_b2PulleyJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PulleyJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2PulleyJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("groundAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groundAnchorA), ctx); + } + + + json->getProperty("groundAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groundAnchorB), ctx); + } + + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("lengthA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lengthA), ctx); + } + + + json->getProperty("lengthB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lengthB), ctx); + } + + + json->getProperty("ratio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ratio), ctx); + } + + + return ok; +} + + +bool js_register_b2PulleyJointDef(se::Object* obj) { + auto* cls = se::Class::create("PulleyJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2PulleyJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("groundAnchorA", _SE(js_PulleyJointDef_groundAnchorA_get), _SE(js_PulleyJointDef_groundAnchorA_set)); + cls->defineProperty("groundAnchorB", _SE(js_PulleyJointDef_groundAnchorB_get), _SE(js_PulleyJointDef_groundAnchorB_set)); + cls->defineProperty("localAnchorA", _SE(js_PulleyJointDef_localAnchorA_get), _SE(js_PulleyJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_PulleyJointDef_localAnchorB_get), _SE(js_PulleyJointDef_localAnchorB_set)); + cls->defineProperty("lengthA", _SE(js_PulleyJointDef_lengthA_get), _SE(js_PulleyJointDef_lengthA_set)); + cls->defineProperty("lengthB", _SE(js_PulleyJointDef_lengthB_get), _SE(js_PulleyJointDef_lengthB_set)); + cls->defineProperty("ratio", _SE(js_PulleyJointDef_ratio_get), _SE(js_PulleyJointDef_ratio_set)); + + cls->defineFunction("Initialize", _SE(js_PulleyJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PulleyJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PulleyJointDef_proto = cls->getProto(); + __jsb_b2PulleyJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2PulleyJoint_class = nullptr; +se::Object* __jsb_b2PulleyJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2PulleyJoint) + +static bool js_PulleyJoint_GetGroundAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2PulleyJoint const *)arg1)->GetGroundAnchorA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetGroundAnchorA) + +static bool js_PulleyJoint_GetGroundAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + b2Vec2 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((b2PulleyJoint const *)arg1)->GetGroundAnchorB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetGroundAnchorB) + +static bool js_PulleyJoint_GetLengthA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetLengthA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetLengthA) + +static bool js_PulleyJoint_GetLengthB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetLengthB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetLengthB) + +static bool js_PulleyJoint_GetRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetRatio) + +static bool js_PulleyJoint_GetCurrentLengthA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetCurrentLengthA(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetCurrentLengthA) + +static bool js_PulleyJoint_GetCurrentLengthB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2PulleyJoint *arg1 = (b2PulleyJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2PulleyJoint const *)arg1)->GetCurrentLengthB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_PulleyJoint_GetCurrentLengthB) + +static bool js_delete_b2PulleyJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2PulleyJoint) + +bool js_register_b2PulleyJoint(se::Object* obj) { + auto* cls = se::Class::create("PulleyJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetGroundAnchorA", _SE(js_PulleyJoint_GetGroundAnchorA)); + cls->defineFunction("GetGroundAnchorB", _SE(js_PulleyJoint_GetGroundAnchorB)); + cls->defineFunction("GetLengthA", _SE(js_PulleyJoint_GetLengthA)); + cls->defineFunction("GetLengthB", _SE(js_PulleyJoint_GetLengthB)); + cls->defineFunction("GetRatio", _SE(js_PulleyJoint_GetRatio)); + cls->defineFunction("GetCurrentLengthA", _SE(js_PulleyJoint_GetCurrentLengthA)); + cls->defineFunction("GetCurrentLengthB", _SE(js_PulleyJoint_GetCurrentLengthB)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2PulleyJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2PulleyJoint_proto = cls->getProto(); + __jsb_b2PulleyJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RevoluteJointDef_class = nullptr; +se::Object* __jsb_b2RevoluteJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RevoluteJointDef) + +static bool js_new_b2RevoluteJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2RevoluteJointDef *result; + result = (b2RevoluteJointDef *)new b2RevoluteJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2RevoluteJointDef, __jsb_b2RevoluteJointDef_class, js_delete_b2RevoluteJointDef) + +static bool js_RevoluteJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJointDef_Initialize) + +static bool js_RevoluteJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_localAnchorA_set) + +static bool js_RevoluteJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_localAnchorA_get) + +static bool js_RevoluteJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_localAnchorB_set) + +static bool js_RevoluteJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_localAnchorB_get) + +static bool js_RevoluteJointDef_referenceAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->referenceAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_referenceAngle_set) + +static bool js_RevoluteJointDef_referenceAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->referenceAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_referenceAngle_get) + +static bool js_RevoluteJointDef_enableLimit_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableLimit); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_enableLimit_set) + +static bool js_RevoluteJointDef_enableLimit_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableLimit, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_enableLimit_get) + +static bool js_RevoluteJointDef_lowerAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lowerAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_lowerAngle_set) + +static bool js_RevoluteJointDef_lowerAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lowerAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_lowerAngle_get) + +static bool js_RevoluteJointDef_upperAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->upperAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_upperAngle_set) + +static bool js_RevoluteJointDef_upperAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->upperAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_upperAngle_get) + +static bool js_RevoluteJointDef_enableMotor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableMotor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_enableMotor_set) + +static bool js_RevoluteJointDef_enableMotor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableMotor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_enableMotor_get) + +static bool js_RevoluteJointDef_motorSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->motorSpeed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_motorSpeed_set) + +static bool js_RevoluteJointDef_motorSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->motorSpeed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_motorSpeed_get) + +static bool js_RevoluteJointDef_maxMotorTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxMotorTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_RevoluteJointDef_maxMotorTorque_set) + +static bool js_RevoluteJointDef_maxMotorTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2RevoluteJointDef *arg1 = (b2RevoluteJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxMotorTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_RevoluteJointDef_maxMotorTorque_get) + +static bool js_delete_b2RevoluteJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RevoluteJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2RevoluteJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("referenceAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->referenceAngle), ctx); + } + + + json->getProperty("enableLimit", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableLimit), ctx); + } + + + json->getProperty("lowerAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lowerAngle), ctx); + } + + + json->getProperty("upperAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->upperAngle), ctx); + } + + + json->getProperty("enableMotor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableMotor), ctx); + } + + + json->getProperty("motorSpeed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->motorSpeed), ctx); + } + + + json->getProperty("maxMotorTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxMotorTorque), ctx); + } + + + return ok; +} + + +bool js_register_b2RevoluteJointDef(se::Object* obj) { + auto* cls = se::Class::create("RevoluteJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2RevoluteJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_RevoluteJointDef_localAnchorA_get), _SE(js_RevoluteJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_RevoluteJointDef_localAnchorB_get), _SE(js_RevoluteJointDef_localAnchorB_set)); + cls->defineProperty("referenceAngle", _SE(js_RevoluteJointDef_referenceAngle_get), _SE(js_RevoluteJointDef_referenceAngle_set)); + cls->defineProperty("enableLimit", _SE(js_RevoluteJointDef_enableLimit_get), _SE(js_RevoluteJointDef_enableLimit_set)); + cls->defineProperty("lowerAngle", _SE(js_RevoluteJointDef_lowerAngle_get), _SE(js_RevoluteJointDef_lowerAngle_set)); + cls->defineProperty("upperAngle", _SE(js_RevoluteJointDef_upperAngle_get), _SE(js_RevoluteJointDef_upperAngle_set)); + cls->defineProperty("enableMotor", _SE(js_RevoluteJointDef_enableMotor_get), _SE(js_RevoluteJointDef_enableMotor_set)); + cls->defineProperty("motorSpeed", _SE(js_RevoluteJointDef_motorSpeed_get), _SE(js_RevoluteJointDef_motorSpeed_set)); + cls->defineProperty("maxMotorTorque", _SE(js_RevoluteJointDef_maxMotorTorque_get), _SE(js_RevoluteJointDef_maxMotorTorque_set)); + + cls->defineFunction("Initialize", _SE(js_RevoluteJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RevoluteJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RevoluteJointDef_proto = cls->getProto(); + __jsb_b2RevoluteJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2RevoluteJoint_class = nullptr; +se::Object* __jsb_b2RevoluteJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2RevoluteJoint) + +static bool js_RevoluteJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RevoluteJoint const *)arg1)->GetLocalAnchorA(); + + 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_RevoluteJoint_GetLocalAnchorA) + +static bool js_RevoluteJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2RevoluteJoint const *)arg1)->GetLocalAnchorB(); + + 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_RevoluteJoint_GetLocalAnchorB) + +static bool js_RevoluteJoint_GetReferenceAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetReferenceAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetReferenceAngle) + +static bool js_RevoluteJoint_GetJointAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetJointAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetJointAngle) + +static bool js_RevoluteJoint_GetJointSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetJointSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetJointSpeed) + +static bool js_RevoluteJoint_IsLimitEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2RevoluteJoint const *)arg1)->IsLimitEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_IsLimitEnabled) + +static bool js_RevoluteJoint_EnableLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_EnableLimit) + +static bool js_RevoluteJoint_GetLowerLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetLowerLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetLowerLimit) + +static bool js_RevoluteJoint_GetUpperLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetUpperLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetUpperLimit) + +static bool js_RevoluteJoint_SetLimits(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->SetLimits(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_SetLimits) + +static bool js_RevoluteJoint_IsMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2RevoluteJoint const *)arg1)->IsMotorEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_IsMotorEnabled) + +static bool js_RevoluteJoint_EnableMotor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableMotor(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_EnableMotor) + +static bool js_RevoluteJoint_SetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMotorSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_SetMotorSpeed) + +static bool js_RevoluteJoint_GetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetMotorSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetMotorSpeed) + +static bool js_RevoluteJoint_SetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxMotorTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_SetMaxMotorTorque) + +static bool js_RevoluteJoint_GetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2RevoluteJoint const *)arg1)->GetMaxMotorTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetMaxMotorTorque) + +static bool js_RevoluteJoint_GetMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2RevoluteJoint *arg1 = (b2RevoluteJoint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2RevoluteJoint const *)arg1)->GetMotorTorque(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RevoluteJoint_GetMotorTorque) + +static bool js_delete_b2RevoluteJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2RevoluteJoint) + +bool js_register_b2RevoluteJoint(se::Object* obj) { + auto* cls = se::Class::create("RevoluteJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_RevoluteJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_RevoluteJoint_GetLocalAnchorB)); + cls->defineFunction("GetReferenceAngle", _SE(js_RevoluteJoint_GetReferenceAngle)); + cls->defineFunction("GetJointAngle", _SE(js_RevoluteJoint_GetJointAngle)); + cls->defineFunction("GetJointSpeed", _SE(js_RevoluteJoint_GetJointSpeed)); + cls->defineFunction("IsLimitEnabled", _SE(js_RevoluteJoint_IsLimitEnabled)); + cls->defineFunction("EnableLimit", _SE(js_RevoluteJoint_EnableLimit)); + cls->defineFunction("GetLowerLimit", _SE(js_RevoluteJoint_GetLowerLimit)); + cls->defineFunction("GetUpperLimit", _SE(js_RevoluteJoint_GetUpperLimit)); + cls->defineFunction("SetLimits", _SE(js_RevoluteJoint_SetLimits)); + cls->defineFunction("IsMotorEnabled", _SE(js_RevoluteJoint_IsMotorEnabled)); + cls->defineFunction("EnableMotor", _SE(js_RevoluteJoint_EnableMotor)); + cls->defineFunction("SetMotorSpeed", _SE(js_RevoluteJoint_SetMotorSpeed)); + cls->defineFunction("GetMotorSpeed", _SE(js_RevoluteJoint_GetMotorSpeed)); + cls->defineFunction("SetMaxMotorTorque", _SE(js_RevoluteJoint_SetMaxMotorTorque)); + cls->defineFunction("GetMaxMotorTorque", _SE(js_RevoluteJoint_GetMaxMotorTorque)); + cls->defineFunction("GetMotorTorque", _SE(js_RevoluteJoint_GetMotorTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2RevoluteJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2RevoluteJoint_proto = cls->getProto(); + __jsb_b2RevoluteJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WeldJointDef_class = nullptr; +se::Object* __jsb_b2WeldJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WeldJointDef) + +static bool js_new_b2WeldJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2WeldJointDef *result; + result = (b2WeldJointDef *)new b2WeldJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2WeldJointDef, __jsb_b2WeldJointDef_class, js_delete_b2WeldJointDef) + +static bool js_WeldJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_WeldJointDef_Initialize) + +static bool js_WeldJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_localAnchorA_set) + +static bool js_WeldJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_localAnchorA_get) + +static bool js_WeldJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_localAnchorB_set) + +static bool js_WeldJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_localAnchorB_get) + +static bool js_WeldJointDef_referenceAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->referenceAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_referenceAngle_set) + +static bool js_WeldJointDef_referenceAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->referenceAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_referenceAngle_get) + +static bool js_WeldJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_frequencyHz_set) + +static bool js_WeldJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_frequencyHz_get) + +static bool js_WeldJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WeldJointDef_dampingRatio_set) + +static bool js_WeldJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WeldJointDef *arg1 = (b2WeldJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WeldJointDef_dampingRatio_get) + +static bool js_delete_b2WeldJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WeldJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2WeldJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("referenceAngle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->referenceAngle), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2WeldJointDef(se::Object* obj) { + auto* cls = se::Class::create("WeldJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2WeldJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_WeldJointDef_localAnchorA_get), _SE(js_WeldJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_WeldJointDef_localAnchorB_get), _SE(js_WeldJointDef_localAnchorB_set)); + cls->defineProperty("referenceAngle", _SE(js_WeldJointDef_referenceAngle_get), _SE(js_WeldJointDef_referenceAngle_set)); + cls->defineProperty("frequencyHz", _SE(js_WeldJointDef_frequencyHz_get), _SE(js_WeldJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_WeldJointDef_dampingRatio_get), _SE(js_WeldJointDef_dampingRatio_set)); + + cls->defineFunction("Initialize", _SE(js_WeldJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WeldJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WeldJointDef_proto = cls->getProto(); + __jsb_b2WeldJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WeldJoint_class = nullptr; +se::Object* __jsb_b2WeldJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WeldJoint) + +static bool js_WeldJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WeldJoint const *)arg1)->GetLocalAnchorA(); + + 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_WeldJoint_GetLocalAnchorA) + +static bool js_WeldJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WeldJoint const *)arg1)->GetLocalAnchorB(); + + 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_WeldJoint_GetLocalAnchorB) + +static bool js_WeldJoint_GetReferenceAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WeldJoint const *)arg1)->GetReferenceAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_GetReferenceAngle) + +static bool js_WeldJoint_SetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetFrequency(arg2); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_SetFrequency) + +static bool js_WeldJoint_GetFrequency(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WeldJoint const *)arg1)->GetFrequency(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_GetFrequency) + +static bool js_WeldJoint_SetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_SetDampingRatio) + +static bool js_WeldJoint_GetDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WeldJoint *arg1 = (b2WeldJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WeldJoint const *)arg1)->GetDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WeldJoint_GetDampingRatio) + +static bool js_delete_b2WeldJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WeldJoint) + +bool js_register_b2WeldJoint(se::Object* obj) { + auto* cls = se::Class::create("WeldJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_WeldJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_WeldJoint_GetLocalAnchorB)); + cls->defineFunction("GetReferenceAngle", _SE(js_WeldJoint_GetReferenceAngle)); + cls->defineFunction("SetFrequency", _SE(js_WeldJoint_SetFrequency)); + cls->defineFunction("GetFrequency", _SE(js_WeldJoint_GetFrequency)); + cls->defineFunction("SetDampingRatio", _SE(js_WeldJoint_SetDampingRatio)); + cls->defineFunction("GetDampingRatio", _SE(js_WeldJoint_GetDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WeldJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WeldJoint_proto = cls->getProto(); + __jsb_b2WeldJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WheelJointDef_class = nullptr; +se::Object* __jsb_b2WheelJointDef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WheelJointDef) + +static bool js_new_b2WheelJointDef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + b2WheelJointDef *result; + result = (b2WheelJointDef *)new b2WheelJointDef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_b2WheelJointDef, __jsb_b2WheelJointDef_class, js_delete_b2WheelJointDef) + +static bool js_WheelJointDef_Initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + b2Body *arg2 = (b2Body *) NULL ; + b2Body *arg3 = (b2Body *) NULL ; + b2Vec2 *arg4 = 0 ; + b2Vec2 *arg5 = 0 ; + b2Vec2 temp4 ; + b2Vec2 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->Initialize(arg2,arg3,(b2Vec2 const &)*arg4,(b2Vec2 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_WheelJointDef_Initialize) + +static bool js_WheelJointDef_localAnchorA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_localAnchorA_set) + +static bool js_WheelJointDef_localAnchorA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_localAnchorA_get) + +static bool js_WheelJointDef_localAnchorB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAnchorB, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_localAnchorB_set) + +static bool js_WheelJointDef_localAnchorB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAnchorB, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAnchorB, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_localAnchorB_get) + +static bool js_WheelJointDef_localAxisA_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->localAxisA, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_localAxisA_set) + +static bool js_WheelJointDef_localAxisA_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->localAxisA, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->localAxisA, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_localAxisA_get) + +static bool js_WheelJointDef_enableMotor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableMotor); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_enableMotor_set) + +static bool js_WheelJointDef_enableMotor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableMotor, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_enableMotor_get) + +static bool js_WheelJointDef_maxMotorTorque_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxMotorTorque, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_maxMotorTorque_set) + +static bool js_WheelJointDef_maxMotorTorque_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxMotorTorque, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_maxMotorTorque_get) + +static bool js_WheelJointDef_motorSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->motorSpeed, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_motorSpeed_set) + +static bool js_WheelJointDef_motorSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->motorSpeed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_motorSpeed_get) + +static bool js_WheelJointDef_frequencyHz_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frequencyHz, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_frequencyHz_set) + +static bool js_WheelJointDef_frequencyHz_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frequencyHz, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_frequencyHz_get) + +static bool js_WheelJointDef_dampingRatio_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dampingRatio, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_WheelJointDef_dampingRatio_set) + +static bool js_WheelJointDef_dampingRatio_get(se::State& s) +{ + CC_UNUSED bool ok = true; + b2WheelJointDef *arg1 = (b2WheelJointDef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dampingRatio, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_WheelJointDef_dampingRatio_get) + +static bool js_delete_b2WheelJointDef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WheelJointDef) + +template<> +bool sevalue_to_native(const se::Value &from, b2WheelJointDef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("localAnchorA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorA), ctx); + } + + + json->getProperty("localAnchorB", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAnchorB), ctx); + } + + + json->getProperty("localAxisA", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->localAxisA), ctx); + } + + + json->getProperty("enableMotor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableMotor), ctx); + } + + + json->getProperty("maxMotorTorque", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxMotorTorque), ctx); + } + + + json->getProperty("motorSpeed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->motorSpeed), ctx); + } + + + json->getProperty("frequencyHz", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->frequencyHz), ctx); + } + + + json->getProperty("dampingRatio", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dampingRatio), ctx); + } + + + return ok; +} + + +bool js_register_b2WheelJointDef(se::Object* obj) { + auto* cls = se::Class::create("WheelJointDef", obj, __jsb_b2JointDef_proto, _SE(js_new_b2WheelJointDef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("localAnchorA", _SE(js_WheelJointDef_localAnchorA_get), _SE(js_WheelJointDef_localAnchorA_set)); + cls->defineProperty("localAnchorB", _SE(js_WheelJointDef_localAnchorB_get), _SE(js_WheelJointDef_localAnchorB_set)); + cls->defineProperty("localAxisA", _SE(js_WheelJointDef_localAxisA_get), _SE(js_WheelJointDef_localAxisA_set)); + cls->defineProperty("enableMotor", _SE(js_WheelJointDef_enableMotor_get), _SE(js_WheelJointDef_enableMotor_set)); + cls->defineProperty("maxMotorTorque", _SE(js_WheelJointDef_maxMotorTorque_get), _SE(js_WheelJointDef_maxMotorTorque_set)); + cls->defineProperty("motorSpeed", _SE(js_WheelJointDef_motorSpeed_get), _SE(js_WheelJointDef_motorSpeed_set)); + cls->defineProperty("frequencyHz", _SE(js_WheelJointDef_frequencyHz_get), _SE(js_WheelJointDef_frequencyHz_set)); + cls->defineProperty("dampingRatio", _SE(js_WheelJointDef_dampingRatio_get), _SE(js_WheelJointDef_dampingRatio_set)); + + cls->defineFunction("Initialize", _SE(js_WheelJointDef_Initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WheelJointDef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WheelJointDef_proto = cls->getProto(); + __jsb_b2WheelJointDef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_b2WheelJoint_class = nullptr; +se::Object* __jsb_b2WheelJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_b2WheelJoint) + +static bool js_WheelJoint_GetLocalAnchorA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WheelJoint const *)arg1)->GetLocalAnchorA(); + + 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_WheelJoint_GetLocalAnchorA) + +static bool js_WheelJoint_GetLocalAnchorB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WheelJoint const *)arg1)->GetLocalAnchorB(); + + 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_WheelJoint_GetLocalAnchorB) + +static bool js_WheelJoint_GetLocalAxisA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + b2Vec2 *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(s); + if (nullptr == arg1) return true; + result = (b2Vec2 *) &((b2WheelJoint const *)arg1)->GetLocalAxisA(); + + 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_WheelJoint_GetLocalAxisA) + +static bool js_WheelJoint_GetJointTranslation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointTranslation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointTranslation) + +static bool js_WheelJoint_GetJointLinearSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointLinearSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointLinearSpeed) + +static bool js_WheelJoint_GetJointAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointAngle) + +static bool js_WheelJoint_GetJointAngularSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetJointAngularSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetJointAngularSpeed) + +static bool js_WheelJoint_IsMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((b2WheelJoint const *)arg1)->IsMotorEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_IsMotorEnabled) + +static bool js_WheelJoint_EnableMotor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EnableMotor(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_EnableMotor) + +static bool js_WheelJoint_SetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMotorSpeed(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetMotorSpeed) + +static bool js_WheelJoint_GetMotorSpeed(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetMotorSpeed(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetMotorSpeed) + +static bool js_WheelJoint_SetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetMaxMotorTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetMaxMotorTorque) + +static bool js_WheelJoint_GetMaxMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetMaxMotorTorque(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetMaxMotorTorque) + +static bool js_WheelJoint_GetMotorTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)((b2WheelJoint const *)arg1)->GetMotorTorque(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetMotorTorque) + +static bool js_WheelJoint_SetSpringFrequencyHz(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSpringFrequencyHz(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetSpringFrequencyHz) + +static bool js_WheelJoint_GetSpringFrequencyHz(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetSpringFrequencyHz(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetSpringFrequencyHz) + +static bool js_WheelJoint_SetSpringDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->SetSpringDampingRatio(arg2); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_SetSpringDampingRatio) + +static bool js_WheelJoint_GetSpringDampingRatio(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + b2WheelJoint *arg1 = (b2WheelJoint *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((b2WheelJoint const *)arg1)->GetSpringDampingRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_WheelJoint_GetSpringDampingRatio) + +static bool js_delete_b2WheelJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_b2WheelJoint) + +bool js_register_b2WheelJoint(se::Object* obj) { + auto* cls = se::Class::create("WheelJoint", obj, __jsb_b2Joint_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("GetLocalAnchorA", _SE(js_WheelJoint_GetLocalAnchorA)); + cls->defineFunction("GetLocalAnchorB", _SE(js_WheelJoint_GetLocalAnchorB)); + cls->defineFunction("GetLocalAxisA", _SE(js_WheelJoint_GetLocalAxisA)); + cls->defineFunction("GetJointTranslation", _SE(js_WheelJoint_GetJointTranslation)); + cls->defineFunction("GetJointLinearSpeed", _SE(js_WheelJoint_GetJointLinearSpeed)); + cls->defineFunction("GetJointAngle", _SE(js_WheelJoint_GetJointAngle)); + cls->defineFunction("GetJointAngularSpeed", _SE(js_WheelJoint_GetJointAngularSpeed)); + cls->defineFunction("IsMotorEnabled", _SE(js_WheelJoint_IsMotorEnabled)); + cls->defineFunction("EnableMotor", _SE(js_WheelJoint_EnableMotor)); + cls->defineFunction("SetMotorSpeed", _SE(js_WheelJoint_SetMotorSpeed)); + cls->defineFunction("GetMotorSpeed", _SE(js_WheelJoint_GetMotorSpeed)); + cls->defineFunction("SetMaxMotorTorque", _SE(js_WheelJoint_SetMaxMotorTorque)); + cls->defineFunction("GetMaxMotorTorque", _SE(js_WheelJoint_GetMaxMotorTorque)); + cls->defineFunction("GetMotorTorque", _SE(js_WheelJoint_GetMotorTorque)); + cls->defineFunction("SetSpringFrequencyHz", _SE(js_WheelJoint_SetSpringFrequencyHz)); + cls->defineFunction("GetSpringFrequencyHz", _SE(js_WheelJoint_GetSpringFrequencyHz)); + cls->defineFunction("SetSpringDampingRatio", _SE(js_WheelJoint_SetSpringDampingRatio)); + cls->defineFunction("GetSpringDampingRatio", _SE(js_WheelJoint_GetSpringDampingRatio)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_b2WheelJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_b2WheelJoint_proto = cls->getProto(); + __jsb_b2WheelJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSBQueryCallback_class = nullptr; +se::Object* __jsb_JSBQueryCallback_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSBQueryCallback) + +static bool js_new_JSBQueryCallback(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSBQueryCallback *result; + result = (JSBQueryCallback *)new JSBQueryCallback(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSBQueryCallback, __jsb_JSBQueryCallback_class, js_delete_JSBQueryCallback) + +static bool js_delete_JSBQueryCallback(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSBQueryCallback) + +static bool js_QueryCallback_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBQueryCallback *arg1 = (JSBQueryCallback *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_QueryCallback_initWithThis) + +static bool js_QueryCallback_ReportFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBQueryCallback *arg1 = (JSBQueryCallback *) NULL ; + b2Fixture *arg2 = (b2Fixture *) 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(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)->ReportFixture(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_QueryCallback_ReportFixture) + +bool js_register_JSBQueryCallback(se::Object* obj) { + auto* cls = se::Class::create("QueryCallback", obj, nullptr, _SE(js_new_JSBQueryCallback)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_QueryCallback_initWithThis)); + cls->defineFunction("ReportFixture", _SE(js_QueryCallback_ReportFixture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSBQueryCallback)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSBQueryCallback_proto = cls->getProto(); + __jsb_JSBQueryCallback_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSBRayCastCallback_class = nullptr; +se::Object* __jsb_JSBRayCastCallback_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSBRayCastCallback) + +static bool js_new_JSBRayCastCallback(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSBRayCastCallback *result; + result = (JSBRayCastCallback *)new JSBRayCastCallback(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSBRayCastCallback, __jsb_JSBRayCastCallback_class, js_delete_JSBRayCastCallback) + +static bool js_delete_JSBRayCastCallback(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSBRayCastCallback) + +static bool js_RayCastCallback_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBRayCastCallback *arg1 = (JSBRayCastCallback *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_RayCastCallback_initWithThis) + +static bool js_RayCastCallback_ReportFixture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBRayCastCallback *arg1 = (JSBRayCastCallback *) NULL ; + b2Fixture *arg2 = (b2Fixture *) NULL ; + b2Vec2 *arg3 = 0 ; + b2Vec2 *arg4 = 0 ; + float arg5 ; + b2Vec2 temp3 ; + b2Vec2 temp4 ; + float result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->ReportFixture(arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_RayCastCallback_ReportFixture) + +bool js_register_JSBRayCastCallback(se::Object* obj) { + auto* cls = se::Class::create("RayCastCallback", obj, nullptr, _SE(js_new_JSBRayCastCallback)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_RayCastCallback_initWithThis)); + cls->defineFunction("ReportFixture", _SE(js_RayCastCallback_ReportFixture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSBRayCastCallback)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSBRayCastCallback_proto = cls->getProto(); + __jsb_JSBRayCastCallback_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSBB2Draw_class = nullptr; +se::Object* __jsb_JSBB2Draw_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSBB2Draw) + +static bool js_new_JSBB2Draw(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSBB2Draw *result; + result = (JSBB2Draw *)new JSBB2Draw(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSBB2Draw, __jsb_JSBB2Draw_class, js_delete_JSBB2Draw) + +static bool js_delete_JSBB2Draw(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSBB2Draw) + +static bool js_Draw_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_initWithThis) + +static bool js_Draw_DrawPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = (b2Vec2 *) NULL ; + int32 arg3 ; + b2Color *arg4 = 0 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->DrawPolygon((b2Vec2 const *)arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawPolygon) + +static bool js_Draw_DrawSolidPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = (b2Vec2 *) NULL ; + int32 arg3 ; + b2Color *arg4 = 0 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->DrawSolidPolygon((b2Vec2 const *)arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawSolidPolygon) + +static bool js_Draw_DrawCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Color *arg4 = 0 ; + b2Vec2 temp2 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->DrawCircle((b2Vec2 const &)*arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawCircle) + +static bool js_Draw_DrawSolidCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Vec2 *arg4 = 0 ; + b2Color *arg5 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp4 ; + b2Color temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->DrawSolidCircle((b2Vec2 const &)*arg2,arg3,(b2Vec2 const &)*arg4,(b2Color const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawSolidCircle) + +static bool js_Draw_DrawSegment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + b2Vec2 *arg3 = 0 ; + b2Color *arg4 = 0 ; + b2Vec2 temp2 ; + b2Vec2 temp3 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->DrawSegment((b2Vec2 const &)*arg2,(b2Vec2 const &)*arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawSegment) + +static bool js_Draw_DrawTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Transform *arg2 = 0 ; + b2Transform temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->DrawTransform((b2Transform const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawTransform) + +static bool js_Draw_DrawPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + b2Vec2 *arg2 = 0 ; + float arg3 ; + b2Color *arg4 = 0 ; + b2Vec2 temp2 ; + b2Color temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->DrawPoint((b2Vec2 const &)*arg2,arg3,(b2Color const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_Draw_DrawPoint) + +static bool js_Draw_SetFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->SetFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_SetFlags) + +static bool js_Draw_GetFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((JSBB2Draw const *)arg1)->GetFlags(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_Draw_GetFlags) + +static bool js_Draw_AppendFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->AppendFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_AppendFlags) + +static bool js_Draw_ClearFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSBB2Draw *arg1 = (JSBB2Draw *) NULL ; + uint32 arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->ClearFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_Draw_ClearFlags) + +bool js_register_JSBB2Draw(se::Object* obj) { + auto* cls = se::Class::create("Draw", obj, nullptr, _SE(js_new_JSBB2Draw)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_Draw_initWithThis)); + cls->defineFunction("DrawPolygon", _SE(js_Draw_DrawPolygon)); + cls->defineFunction("DrawSolidPolygon", _SE(js_Draw_DrawSolidPolygon)); + cls->defineFunction("DrawCircle", _SE(js_Draw_DrawCircle)); + cls->defineFunction("DrawSolidCircle", _SE(js_Draw_DrawSolidCircle)); + cls->defineFunction("DrawSegment", _SE(js_Draw_DrawSegment)); + cls->defineFunction("DrawTransform", _SE(js_Draw_DrawTransform)); + cls->defineFunction("DrawPoint", _SE(js_Draw_DrawPoint)); + cls->defineFunction("SetFlags", _SE(js_Draw_SetFlags)); + cls->defineFunction("GetFlags", _SE(js_Draw_GetFlags)); + cls->defineFunction("AppendFlags", _SE(js_Draw_AppendFlags)); + cls->defineFunction("ClearFlags", _SE(js_Draw_ClearFlags)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSBB2Draw)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSBB2Draw_proto = cls->getProto(); + __jsb_JSBB2Draw_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_JSB_b2ContactListener_class = nullptr; +se::Object* __jsb_JSB_b2ContactListener_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_JSB_b2ContactListener) + +static bool js_new_JSB_b2ContactListener(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + JSB_b2ContactListener *result; + result = (JSB_b2ContactListener *)new JSB_b2ContactListener(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_JSB_b2ContactListener, __jsb_JSB_b2ContactListener_class, js_delete_JSB_b2ContactListener) + +static bool js_delete_JSB_b2ContactListener(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_JSB_b2ContactListener) + +static bool js_ContactListener_initWithThis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + se::Object *arg2 = (se::Object *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithThis(arg2); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_initWithThis) + +static bool js_ContactListener_BeginContact(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->BeginContact(arg2); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_BeginContact) + +static bool js_ContactListener_EndContact(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->EndContact(arg2); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_EndContact) + +static bool js_ContactListener_PreSolve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + b2Manifold *arg3 = (b2Manifold *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->PreSolve(arg2,(b2Manifold const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_PreSolve) + +static bool js_ContactListener_PostSolve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + JSB_b2ContactListener *arg1 = (JSB_b2ContactListener *) NULL ; + b2Contact *arg2 = (b2Contact *) NULL ; + b2ContactImpulse *arg3 = (b2ContactImpulse *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->PostSolve(arg2,(b2ContactImpulse const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_ContactListener_PostSolve) + +bool js_register_JSB_b2ContactListener(se::Object* obj) { + auto* cls = se::Class::create("ContactListener", obj, nullptr, _SE(js_new_JSB_b2ContactListener)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithThis", _SE(js_ContactListener_initWithThis)); + cls->defineFunction("BeginContact", _SE(js_ContactListener_BeginContact)); + cls->defineFunction("EndContact", _SE(js_ContactListener_EndContact)); + cls->defineFunction("PreSolve", _SE(js_ContactListener_PreSolve)); + cls->defineFunction("PostSolve", _SE(js_ContactListener_PostSolve)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_JSB_b2ContactListener)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_JSB_b2ContactListener_proto = cls->getProto(); + __jsb_JSB_b2ContactListener_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_box2d(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("b2jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("b2jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_b2Vec2(ns); + js_register_b2Vec3(ns); + js_register_b2Mat22(ns); + js_register_b2Mat33(ns); + js_register_b2Rot(ns); + js_register_b2Transform(ns); + js_register_b2Sweep(ns); + js_register_b2MassData(ns); + js_register_b2Shape(ns); + js_register_b2Color(ns); + js_register_b2ContactFeature(ns); + js_register_b2ContactID(ns); + js_register_b2ManifoldPoint(ns); + js_register_b2Manifold(ns); + js_register_b2WorldManifold(ns); + js_register_b2ClipVertex(ns); + js_register_b2RayCastInput(ns); + js_register_b2RayCastOutput(ns); + js_register_b2AABB(ns); + js_register_b2Jacobian(ns); + js_register_b2JointEdge(ns); + js_register_b2JointDef(ns); + js_register_b2Joint(ns); + js_register_b2ChainShape(ns); + js_register_b2CircleShape(ns); + js_register_b2EdgeShape(ns); + js_register_b2PolygonShape(ns); + js_register_b2Pair(ns); + js_register_b2BroadPhase(ns); + js_register_b2TreeNode(ns); + js_register_b2DynamicTree(ns); + js_register_b2BodyDef(ns); + js_register_b2Body(ns); + js_register_b2ContactEdge(ns); + js_register_b2Contact(ns); + js_register_b2Filter(ns); + js_register_b2FixtureDef(ns); + js_register_b2FixtureProxy(ns); + js_register_b2Fixture(ns); + js_register_b2Profile(ns); + js_register_b2TimeStep(ns); + js_register_b2Position(ns); + js_register_b2Velocity(ns); + js_register_b2SolverData(ns); + js_register_b2World(ns); + js_register_b2DestructionListener(ns); + js_register_b2ContactFilter(ns); + js_register_b2ContactImpulse(ns); + js_register_b2RopeJointDef(ns); + js_register_b2RopeJoint(ns); + js_register_b2FrictionJointDef(ns); + js_register_b2FrictionJoint(ns); + js_register_b2DistanceJointDef(ns); + js_register_b2DistanceJoint(ns); + js_register_b2GearJointDef(ns); + js_register_b2GearJoint(ns); + js_register_b2MotorJointDef(ns); + js_register_b2MotorJoint(ns); + js_register_b2MouseJointDef(ns); + js_register_b2MouseJoint(ns); + js_register_b2PrismaticJointDef(ns); + js_register_b2PrismaticJoint(ns); + js_register_b2PulleyJointDef(ns); + js_register_b2PulleyJoint(ns); + js_register_b2RevoluteJointDef(ns); + js_register_b2RevoluteJoint(ns); + js_register_b2WeldJointDef(ns); + js_register_b2WeldJoint(ns); + js_register_b2WheelJointDef(ns); + js_register_b2WheelJoint(ns); + js_register_JSBQueryCallback(ns); + js_register_JSBRayCastCallback(ns); + js_register_JSBB2Draw(ns); + js_register_JSB_b2ContactListener(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_box2d_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_box2d_auto.h new file mode 100644 index 0000000000..6392896a36 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_box2d_auto.h @@ -0,0 +1,590 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/Box2dCallbacks.h" + + + +bool register_all_box2d(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(b2Vec2); +extern se::Object *__jsb_b2Vec2_proto; // NOLINT +extern se::Class * __jsb_b2Vec2_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec2 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Vec3); +extern se::Object *__jsb_b2Vec3_proto; // NOLINT +extern se::Class * __jsb_b2Vec3_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Vec3 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Mat22); +extern se::Object *__jsb_b2Mat22_proto; // NOLINT +extern se::Class * __jsb_b2Mat22_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat22 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Mat33); +extern se::Object *__jsb_b2Mat33_proto; // NOLINT +extern se::Class * __jsb_b2Mat33_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Mat33 * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Rot); +extern se::Object *__jsb_b2Rot_proto; // NOLINT +extern se::Class * __jsb_b2Rot_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Rot * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Transform); +extern se::Object *__jsb_b2Transform_proto; // NOLINT +extern se::Class * __jsb_b2Transform_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Transform * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Sweep); +extern se::Object *__jsb_b2Sweep_proto; // NOLINT +extern se::Class * __jsb_b2Sweep_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Sweep * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2MassData); +extern se::Object *__jsb_b2MassData_proto; // NOLINT +extern se::Class * __jsb_b2MassData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2MassData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Shape); +extern se::Object *__jsb_b2Shape_proto; // NOLINT +extern se::Class * __jsb_b2Shape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Color); +extern se::Object *__jsb_b2Color_proto; // NOLINT +extern se::Class * __jsb_b2Color_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Color * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2ContactFeature); +extern se::Object *__jsb_b2ContactFeature_proto; // NOLINT +extern se::Class * __jsb_b2ContactFeature_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactFeature * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2ContactID); +extern se::Object *__jsb_b2ContactID_proto; // NOLINT +extern se::Class * __jsb_b2ContactID_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ManifoldPoint); +extern se::Object *__jsb_b2ManifoldPoint_proto; // NOLINT +extern se::Class * __jsb_b2ManifoldPoint_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ManifoldPoint * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Manifold); +extern se::Object *__jsb_b2Manifold_proto; // NOLINT +extern se::Class * __jsb_b2Manifold_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Manifold * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2WorldManifold); +extern se::Object *__jsb_b2WorldManifold_proto; // NOLINT +extern se::Class * __jsb_b2WorldManifold_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2WorldManifold * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2ClipVertex); +extern se::Object *__jsb_b2ClipVertex_proto; // NOLINT +extern se::Class * __jsb_b2ClipVertex_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ClipVertex * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RayCastInput); +extern se::Object *__jsb_b2RayCastInput_proto; // NOLINT +extern se::Class * __jsb_b2RayCastInput_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastInput * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RayCastOutput); +extern se::Object *__jsb_b2RayCastOutput_proto; // NOLINT +extern se::Class * __jsb_b2RayCastOutput_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RayCastOutput * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2AABB); +extern se::Object *__jsb_b2AABB_proto; // NOLINT +extern se::Class * __jsb_b2AABB_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2AABB * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Jacobian); +extern se::Object *__jsb_b2Jacobian_proto; // NOLINT +extern se::Class * __jsb_b2Jacobian_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Jacobian * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2JointEdge); +extern se::Object *__jsb_b2JointEdge_proto; // NOLINT +extern se::Class * __jsb_b2JointEdge_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2JointEdge * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2JointDef); +extern se::Object *__jsb_b2JointDef_proto; // NOLINT +extern se::Class * __jsb_b2JointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2JointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Joint); +extern se::Object *__jsb_b2Joint_proto; // NOLINT +extern se::Class * __jsb_b2Joint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ChainShape); +extern se::Object *__jsb_b2ChainShape_proto; // NOLINT +extern se::Class * __jsb_b2ChainShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2CircleShape); +extern se::Object *__jsb_b2CircleShape_proto; // NOLINT +extern se::Class * __jsb_b2CircleShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2EdgeShape); +extern se::Object *__jsb_b2EdgeShape_proto; // NOLINT +extern se::Class * __jsb_b2EdgeShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2PolygonShape); +extern se::Object *__jsb_b2PolygonShape_proto; // NOLINT +extern se::Class * __jsb_b2PolygonShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Pair); +extern se::Object *__jsb_b2Pair_proto; // NOLINT +extern se::Class * __jsb_b2Pair_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Pair * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2BroadPhase); +extern se::Object *__jsb_b2BroadPhase_proto; // NOLINT +extern se::Class * __jsb_b2BroadPhase_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2TreeNode); +extern se::Object *__jsb_b2TreeNode_proto; // NOLINT +extern se::Class * __jsb_b2TreeNode_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2TreeNode * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2DynamicTree); +extern se::Object *__jsb_b2DynamicTree_proto; // NOLINT +extern se::Class * __jsb_b2DynamicTree_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2BodyDef); +extern se::Object *__jsb_b2BodyDef_proto; // NOLINT +extern se::Class * __jsb_b2BodyDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2BodyDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Body); +extern se::Object *__jsb_b2Body_proto; // NOLINT +extern se::Class * __jsb_b2Body_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ContactEdge); +extern se::Object *__jsb_b2ContactEdge_proto; // NOLINT +extern se::Class * __jsb_b2ContactEdge_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactEdge * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Contact); +extern se::Object *__jsb_b2Contact_proto; // NOLINT +extern se::Class * __jsb_b2Contact_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Filter); +extern se::Object *__jsb_b2Filter_proto; // NOLINT +extern se::Class * __jsb_b2Filter_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Filter * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2FixtureDef); +extern se::Object *__jsb_b2FixtureDef_proto; // NOLINT +extern se::Class * __jsb_b2FixtureDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2FixtureProxy); +extern se::Object *__jsb_b2FixtureProxy_proto; // NOLINT +extern se::Class * __jsb_b2FixtureProxy_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2FixtureProxy * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Fixture); +extern se::Object *__jsb_b2Fixture_proto; // NOLINT +extern se::Class * __jsb_b2Fixture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2Profile); +extern se::Object *__jsb_b2Profile_proto; // NOLINT +extern se::Class * __jsb_b2Profile_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Profile * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2TimeStep); +extern se::Object *__jsb_b2TimeStep_proto; // NOLINT +extern se::Class * __jsb_b2TimeStep_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2TimeStep * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Position); +extern se::Object *__jsb_b2Position_proto; // NOLINT +extern se::Class * __jsb_b2Position_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Position * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2Velocity); +extern se::Object *__jsb_b2Velocity_proto; // NOLINT +extern se::Class * __jsb_b2Velocity_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2Velocity * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2SolverData); +extern se::Object *__jsb_b2SolverData_proto; // NOLINT +extern se::Class * __jsb_b2SolverData_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2SolverData * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2World); +extern se::Object *__jsb_b2World_proto; // NOLINT +extern se::Class * __jsb_b2World_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2DestructionListener); +extern se::Object *__jsb_b2DestructionListener_proto; // NOLINT +extern se::Class * __jsb_b2DestructionListener_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ContactFilter); +extern se::Object *__jsb_b2ContactFilter_proto; // NOLINT +extern se::Class * __jsb_b2ContactFilter_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2ContactImpulse); +extern se::Object *__jsb_b2ContactImpulse_proto; // NOLINT +extern se::Class * __jsb_b2ContactImpulse_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2ContactImpulse * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RopeJointDef); +extern se::Object *__jsb_b2RopeJointDef_proto; // NOLINT +extern se::Class * __jsb_b2RopeJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RopeJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RopeJoint); +extern se::Object *__jsb_b2RopeJoint_proto; // NOLINT +extern se::Class * __jsb_b2RopeJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2FrictionJointDef); +extern se::Object *__jsb_b2FrictionJointDef_proto; // NOLINT +extern se::Class * __jsb_b2FrictionJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2FrictionJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2FrictionJoint); +extern se::Object *__jsb_b2FrictionJoint_proto; // NOLINT +extern se::Class * __jsb_b2FrictionJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2DistanceJointDef); +extern se::Object *__jsb_b2DistanceJointDef_proto; // NOLINT +extern se::Class * __jsb_b2DistanceJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2DistanceJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2DistanceJoint); +extern se::Object *__jsb_b2DistanceJoint_proto; // NOLINT +extern se::Class * __jsb_b2DistanceJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2GearJointDef); +extern se::Object *__jsb_b2GearJointDef_proto; // NOLINT +extern se::Class * __jsb_b2GearJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2GearJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2GearJoint); +extern se::Object *__jsb_b2GearJoint_proto; // NOLINT +extern se::Class * __jsb_b2GearJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2MotorJointDef); +extern se::Object *__jsb_b2MotorJointDef_proto; // NOLINT +extern se::Class * __jsb_b2MotorJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2MotorJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2MotorJoint); +extern se::Object *__jsb_b2MotorJoint_proto; // NOLINT +extern se::Class * __jsb_b2MotorJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2MouseJointDef); +extern se::Object *__jsb_b2MouseJointDef_proto; // NOLINT +extern se::Class * __jsb_b2MouseJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2MouseJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2MouseJoint); +extern se::Object *__jsb_b2MouseJoint_proto; // NOLINT +extern se::Class * __jsb_b2MouseJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2PrismaticJointDef); +extern se::Object *__jsb_b2PrismaticJointDef_proto; // NOLINT +extern se::Class * __jsb_b2PrismaticJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2PrismaticJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2PrismaticJoint); +extern se::Object *__jsb_b2PrismaticJoint_proto; // NOLINT +extern se::Class * __jsb_b2PrismaticJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2PulleyJointDef); +extern se::Object *__jsb_b2PulleyJointDef_proto; // NOLINT +extern se::Class * __jsb_b2PulleyJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2PulleyJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2PulleyJoint); +extern se::Object *__jsb_b2PulleyJoint_proto; // NOLINT +extern se::Class * __jsb_b2PulleyJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2RevoluteJointDef); +extern se::Object *__jsb_b2RevoluteJointDef_proto; // NOLINT +extern se::Class * __jsb_b2RevoluteJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2RevoluteJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2RevoluteJoint); +extern se::Object *__jsb_b2RevoluteJoint_proto; // NOLINT +extern se::Class * __jsb_b2RevoluteJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2WeldJointDef); +extern se::Object *__jsb_b2WeldJointDef_proto; // NOLINT +extern se::Class * __jsb_b2WeldJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2WeldJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2WeldJoint); +extern se::Object *__jsb_b2WeldJoint_proto; // NOLINT +extern se::Class * __jsb_b2WeldJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(b2WheelJointDef); +extern se::Object *__jsb_b2WheelJointDef_proto; // NOLINT +extern se::Class * __jsb_b2WheelJointDef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, b2WheelJointDef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(b2WheelJoint); +extern se::Object *__jsb_b2WheelJoint_proto; // NOLINT +extern se::Class * __jsb_b2WheelJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSBQueryCallback); +extern se::Object *__jsb_JSBQueryCallback_proto; // NOLINT +extern se::Class * __jsb_JSBQueryCallback_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSBRayCastCallback); +extern se::Object *__jsb_JSBRayCastCallback_proto; // NOLINT +extern se::Class * __jsb_JSBRayCastCallback_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSBB2Draw); +extern se::Object *__jsb_JSBB2Draw_proto; // NOLINT +extern se::Class * __jsb_JSBB2Draw_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(JSB_b2ContactListener); +extern se::Object *__jsb_JSB_b2ContactListener_proto; // NOLINT +extern se::Class * __jsb_JSB_b2ContactListener_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_cocos_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_cocos_auto.cpp new file mode 100644 index 0000000000..7187460b4f --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_cocos_auto.cpp @@ -0,0 +1,6672 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" + + +#define cc_ICanvasRenderingContext2D_width_set(self_, val_) self_->setWidth(val_) + + +#define cc_ICanvasRenderingContext2D_height_set(self_, val_) self_->setHeight(val_) + + +#define cc_ICanvasRenderingContext2D_lineWidth_set(self_, val_) self_->setLineWidth(val_) + + +#define cc_ICanvasRenderingContext2D_fillStyle_set(self_, val_) self_->setFillStyle(val_) + + +#define cc_ICanvasRenderingContext2D_font_set(self_, val_) self_->setFont(val_) + + +#define cc_ICanvasRenderingContext2D_globalCompositeOperation_set(self_, val_) self_->setGlobalCompositeOperation(val_) + + +#define cc_ICanvasRenderingContext2D_lineCap_set(self_, val_) self_->setLineCap(val_) + + +#define cc_ICanvasRenderingContext2D_strokeStyle_set(self_, val_) self_->setStrokeStyle(val_) + + +#define cc_ICanvasRenderingContext2D_lineJoin_set(self_, val_) self_->setLineJoin(val_) + + +#define cc_ICanvasRenderingContext2D_textAlign_set(self_, val_) self_->setTextAlign(val_) + + +#define cc_ICanvasRenderingContext2D_textBaseline_set(self_, val_) self_->setTextBaseline(val_) + + +#define cc_CCObject_name_get(self_) self_->getName() +#define cc_CCObject_name_set(self_, val_) self_->setName(val_) + + +#define cc_CCObject_hideFlags_get(self_) self_->getHideFlags() +#define cc_CCObject_hideFlags_set(self_, val_) self_->setHideFlags(val_) + + +#define cc_CCObject_isValid_get(self_) self_->isValid() + + + +static bool js_cc_clampf(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::clampf(arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_clampf) + +se::Class* __jsb_cc_Vec2_class = nullptr; +se::Object* __jsb_cc_Vec2_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec2) + +static bool js_new_cc_Vec2__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec2 *result; + result = (cc::Vec2 *)new cc::Vec2(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec2 *)new cc::Vec2(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec2 *)new cc::Vec2((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec2 *arg1 = 0 ; + cc::Vec2 *arg2 = 0 ; + cc::Vec2 temp1 ; + cc::Vec2 temp2 ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Vec2 *)new cc::Vec2((cc::Vec2 const &)*arg1,(cc::Vec2 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec2 *arg1 = 0 ; + cc::Vec2 temp1 ; + cc::Vec2 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Vec2 *)new cc::Vec2((cc::Vec2 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec2(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Vec2__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec2__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec2__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec2__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec2__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec2"); + return false; +} +SE_BIND_CTOR(js_new_cc_Vec2, __jsb_cc_Vec2_class, js_delete_cc_Vec2) + +static bool js_delete_cc_Vec2(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec2) + +bool js_register_cc_Vec2(se::Object* obj) { + auto* cls = se::Class::create("Vec2", obj, nullptr, _SE(js_new_cc_Vec2)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Vec2)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Vec2_proto = cls->getProto(); + __jsb_cc_Vec2_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Color_class = nullptr; +se::Object* __jsb_cc_Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Color) + +static bool js_new_cc_Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Color *result; + result = (cc::Color *)new cc::Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint8_t arg1 ; + uint8_t arg2 ; + uint8_t arg3 ; + uint8_t arg4 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Color *)new cc::Color(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint8_t *arg1 = (uint8_t *) NULL ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Color *)new cc::Color((uint8_t const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint32_t arg1 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Color *)new cc::Color(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Color *arg1 = 0 ; + cc::Color *arg2 = 0 ; + cc::Color temp1 ; + cc::Color temp2 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Color *)new cc::Color((cc::Color const &)*arg1,(cc::Color const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Color *arg1 = 0 ; + cc::Color temp1 ; + cc::Color *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Color *)new cc::Color((cc::Color const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Color__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_Color__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Color__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Color__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Color__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Color__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Color"); + return false; +} +SE_BIND_CTOR(js_new_cc_Color, __jsb_cc_Color_class, js_delete_cc_Color) + +static bool js_delete_cc_Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Color) + +bool js_register_cc_Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_cc_Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Color_proto = cls->getProto(); + __jsb_cc_Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Vec3_class = nullptr; +se::Object* __jsb_cc_Vec3_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec3) + +static bool js_new_cc_Vec3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *result; + result = (cc::Vec3 *)new cc::Vec3(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec3 *)new cc::Vec3(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec3 *)new cc::Vec3((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp1 ; + cc::Vec3 temp2 ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Vec3 *)new cc::Vec3((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + cc::Vec3 temp1 ; + cc::Vec3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Vec3 *)new cc::Vec3((cc::Vec3 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec3(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Vec3__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_Vec3__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec3__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec3__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec3__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec3"); + return false; +} +SE_BIND_CTOR(js_new_cc_Vec3, __jsb_cc_Vec3_class, js_delete_cc_Vec3) + +static bool js_delete_cc_Vec3(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec3) + +bool js_register_cc_Vec3(se::Object* obj) { + auto* cls = se::Class::create("Vec3", obj, nullptr, _SE(js_new_cc_Vec3)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Vec3)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Vec3_proto = cls->getProto(); + __jsb_cc_Vec3_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Vec4_class = nullptr; +se::Object* __jsb_cc_Vec4_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Vec4) + +static bool js_new_cc_Vec4__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec4 *result; + result = (cc::Vec4 *)new cc::Vec4(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec4 *)new cc::Vec4(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Vec4 *)new cc::Vec4((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec4 *arg1 = 0 ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp1 ; + cc::Vec4 temp2 ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::Vec4 *)new cc::Vec4((cc::Vec4 const &)*arg1,(cc::Vec4 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec4 *arg1 = 0 ; + cc::Vec4 temp1 ; + cc::Vec4 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Vec4 *)new cc::Vec4((cc::Vec4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Vec4(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Vec4__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_Vec4__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec4__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Vec4__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Vec4__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vec4"); + return false; +} +SE_BIND_CTOR(js_new_cc_Vec4, __jsb_cc_Vec4_class, js_delete_cc_Vec4) + +static bool js_delete_cc_Vec4(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Vec4) + +bool js_register_cc_Vec4(se::Object* obj) { + auto* cls = se::Class::create("Vec4", obj, nullptr, _SE(js_new_cc_Vec4)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Vec4)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Vec4_proto = cls->getProto(); + __jsb_cc_Vec4_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mat3_class = nullptr; +se::Object* __jsb_cc_Mat3_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mat3) + +static bool js_new_cc_Mat3__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat3 *result; + result = (cc::Mat3 *)new cc::Mat3(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat3 *)new cc::Mat3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat3 *)new cc::Mat3((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat3 *arg1 = 0 ; + cc::Mat3 temp1 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat3 *)new cc::Mat3((cc::Mat3 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *arg1 = 0 ; + cc::Mat4 temp1 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat3 *)new cc::Mat3((cc::Mat4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Quaternion *arg1 = 0 ; + cc::Quaternion temp1 ; + cc::Mat3 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat3 *)new cc::Mat3((cc::Quaternion const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat3(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Mat3__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 9) { + ret = js_new_cc_Mat3__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat3__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat3"); + return false; +} +SE_BIND_CTOR(js_new_cc_Mat3, __jsb_cc_Mat3_class, js_delete_cc_Mat3) + +static bool js_delete_cc_Mat3(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mat3) + +bool js_register_cc_Mat3(se::Object* obj) { + auto* cls = se::Class::create("Mat3", obj, nullptr, _SE(js_new_cc_Mat3)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mat3)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mat3_proto = cls->getProto(); + __jsb_cc_Mat3_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Mat4_class = nullptr; +se::Object* __jsb_cc_Mat4_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Mat4) + +static bool js_new_cc_Mat4__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *result; + result = (cc::Mat4 *)new cc::Mat4(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + float arg10 ; + float arg11 ; + float arg12 ; + float arg13 ; + float arg14 ; + float arg15 ; + float arg16 ; + cc::Mat4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &arg11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[11], &arg12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[12], &arg13, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[13], &arg14, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[14], &arg15, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[15], &arg16, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat4 *)new cc::Mat4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Mat4 *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Mat4 *)new cc::Mat4((float const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *arg1 = 0 ; + cc::Mat4 temp1 ; + cc::Mat4 *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Mat4 *)new cc::Mat4((cc::Mat4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Mat4(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Mat4__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 16) { + ret = js_new_cc_Mat4__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat4__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Mat4__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Mat4"); + return false; +} +SE_BIND_CTOR(js_new_cc_Mat4, __jsb_cc_Mat4_class, js_delete_cc_Mat4) + +static bool js_delete_cc_Mat4(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Mat4) + +bool js_register_cc_Mat4(se::Object* obj) { + auto* cls = se::Class::create("Mat4", obj, nullptr, _SE(js_new_cc_Mat4)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Mat4)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Mat4_proto = cls->getProto(); + __jsb_cc_Mat4_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Quaternion_class = nullptr; +se::Object* __jsb_cc_Quaternion_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Quaternion) + +static bool js_new_cc_Quaternion__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Quaternion *result; + result = (cc::Quaternion *)new cc::Quaternion(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Quaternion *)new cc::Quaternion(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float *arg1 = (float *) NULL ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Quaternion *)new cc::Quaternion(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Mat4 *arg1 = 0 ; + cc::Mat4 temp1 ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Quaternion *)new cc::Quaternion((cc::Mat4 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + float arg2 ; + cc::Vec3 temp1 ; + cc::Quaternion *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Quaternion *)new cc::Quaternion((cc::Vec3 const &)*arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Quaternion(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Quaternion__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_Quaternion__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Quaternion__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Quaternion__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_Quaternion__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Quat"); + return false; +} +SE_BIND_CTOR(js_new_cc_Quaternion, __jsb_cc_Quaternion_class, js_delete_cc_Quaternion) + +static bool js_delete_cc_Quaternion(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Quaternion) + +bool js_register_cc_Quaternion(se::Object* obj) { + auto* cls = se::Class::create("Quat", obj, nullptr, _SE(js_new_cc_Quaternion)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Quaternion)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Quaternion_proto = cls->getProto(); + __jsb_cc_Quaternion_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CCObject_class = nullptr; +se::Object* __jsb_cc_CCObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CCObject) + +static bool js_cc_CCObject_deferredDestroy_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::CCObject::deferredDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject_deferredDestroy_static) + +static bool js_new_cc_CCObject__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string arg1 ; + cc::CCObject *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::CCObject *)new cc::CCObject(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_CCObject__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::CCObject *result; + result = (cc::CCObject *)new cc::CCObject(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_CCObject(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_cc_CCObject__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_CCObject__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of CCObject"); + return false; +} +SE_BIND_CTOR(js_new_cc_CCObject, __jsb_cc_CCObject_class, js_delete_cc_CCObject) + +static bool js_delete_cc_CCObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CCObject) + +static bool js_cc_CCObject_destruct(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destruct(); + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject_destruct) + +static bool js_cc_CCObject__destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) 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(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_CCObject__destroy) + +static bool js_cc_CCObject__destroyImmediate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyImmediate(); + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject__destroyImmediate) + +static bool js_cc_CCObject_toString(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::CCObject const *)arg1)->toString(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_CCObject_toString) + +static bool js_cc_CCObject__objFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_objFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject__objFlags_set) + +static bool js_cc_CCObject__objFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_objFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_objFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CCObject__objFlags_get) + +static bool js_cc_CCObject__name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject__name_set) + +static bool js_cc_CCObject__name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CCObject__name_get) + +static bool js_cc_CCObject_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_CCObject_name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject_name_set) + +static bool js_cc_CCObject_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_CCObject_name_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_CCObject_name_get) + +static bool js_cc_CCObject_hideFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + cc::CCObject::Flags arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_CCObject_hideFlags_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CCObject_hideFlags_set) + +static bool js_cc_CCObject_hideFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + cc::CCObject::Flags result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::CCObject::Flags)cc_CCObject_hideFlags_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_CCObject_hideFlags_get) + +static bool js_cc_CCObject_isValid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_CCObject_isValid_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CCObject_isValid_get) + +bool js_register_cc_CCObject(se::Object* obj) { + auto* cls = se::Class::create("CCObject", obj, nullptr, _SE(js_new_cc_CCObject)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_objFlags", _SE(js_cc_CCObject__objFlags_get), _SE(js_cc_CCObject__objFlags_set)); + cls->defineProperty("_name", _SE(js_cc_CCObject__name_get), _SE(js_cc_CCObject__name_set)); + cls->defineProperty("name", _SE(js_cc_CCObject_name_get), _SE(js_cc_CCObject_name_set)); + cls->defineProperty("hideFlags", _SE(js_cc_CCObject_hideFlags_get), _SE(js_cc_CCObject_hideFlags_set)); + cls->defineProperty("isValid", _SE(js_cc_CCObject_isValid_get), nullptr); + + cls->defineFunction("destruct", _SE(js_cc_CCObject_destruct)); + cls->defineFunction("_destroy", _SE(js_cc_CCObject__destroy)); + cls->defineFunction("_destroyImmediate", _SE(js_cc_CCObject__destroyImmediate)); + cls->defineFunction("toString", _SE(js_cc_CCObject_toString)); + + + cls->defineStaticFunction("deferredDestroy", _SE(js_cc_CCObject_deferredDestroy_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CCObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CCObject_proto = cls->getProto(); + __jsb_cc_CCObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_isObjectValid__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + bool arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::isObjectValid(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_isObjectValid__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::CCObject *arg1 = (cc::CCObject *) NULL ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::isObjectValid(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_isObjectValid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_isObjectValid__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_isObjectValid__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_isObjectValid) + +se::Class* __jsb_cc_JSBNativeDataHolder_class = nullptr; +se::Object* __jsb_cc_JSBNativeDataHolder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_JSBNativeDataHolder) + +static bool js_new_cc_JSBNativeDataHolder__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::JSBNativeDataHolder *result; + result = (cc::JSBNativeDataHolder *)new cc::JSBNativeDataHolder(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_JSBNativeDataHolder__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + uint8_t *arg1 = (uint8_t *) NULL ; + cc::JSBNativeDataHolder *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::JSBNativeDataHolder *)new cc::JSBNativeDataHolder(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_JSBNativeDataHolder(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_JSBNativeDataHolder__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_JSBNativeDataHolder__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of JSBNativeDataHolder"); + return false; +} +SE_BIND_CTOR(js_new_cc_JSBNativeDataHolder, __jsb_cc_JSBNativeDataHolder_class, js_delete_cc_JSBNativeDataHolder) + +static bool js_delete_cc_JSBNativeDataHolder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_JSBNativeDataHolder) + +static bool js_cc_JSBNativeDataHolder_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::JSBNativeDataHolder *arg1 = (cc::JSBNativeDataHolder *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_JSBNativeDataHolder_destroy) + +bool js_register_cc_JSBNativeDataHolder(se::Object* obj) { + auto* cls = se::Class::create("JSBNativeDataHolder", obj, nullptr, _SE(js_new_cc_JSBNativeDataHolder)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_JSBNativeDataHolder_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_JSBNativeDataHolder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_JSBNativeDataHolder_proto = cls->getProto(); + __jsb_cc_JSBNativeDataHolder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICanvasGradient_class = nullptr; +se::Object* __jsb_cc_ICanvasGradient_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICanvasGradient) + +static bool js_delete_cc_ICanvasGradient(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICanvasGradient) + +static bool js_cc_ICanvasGradient_addColorStop(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasGradient *arg1 = (cc::ICanvasGradient *) NULL ; + float arg2 ; + ccstd::string *arg3 = 0 ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addColorStop(arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasGradient_addColorStop) + +bool js_register_cc_ICanvasGradient(se::Object* obj) { + auto* cls = se::Class::create("ICanvasGradient", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addColorStop", _SE(js_cc_ICanvasGradient_addColorStop)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICanvasGradient)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICanvasGradient_proto = cls->getProto(); + __jsb_cc_ICanvasGradient_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ICanvasRenderingContext2D_class = nullptr; +se::Object* __jsb_cc_ICanvasRenderingContext2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ICanvasRenderingContext2D) + +static bool js_cc_ICanvasRenderingContext2D_rect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->rect(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_rect) + +static bool js_cc_ICanvasRenderingContext2D_clearRect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->clearRect(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_clearRect) + +static bool js_cc_ICanvasRenderingContext2D_createLinearGradient(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::ICanvasGradient *result = 0 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::ICanvasGradient *)(arg1)->createLinearGradient(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_createLinearGradient) + +static bool js_cc_ICanvasRenderingContext2D_save(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->save(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_save) + +static bool js_cc_ICanvasRenderingContext2D_beginPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginPath(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_beginPath) + +static bool js_cc_ICanvasRenderingContext2D_closePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->closePath(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_closePath) + +static bool js_cc_ICanvasRenderingContext2D_moveTo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->moveTo(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_moveTo) + +static bool js_cc_ICanvasRenderingContext2D_lineTo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->lineTo(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_lineTo) + +static bool js_cc_ICanvasRenderingContext2D_fill(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->fill(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fill) + +static bool js_cc_ICanvasRenderingContext2D_stroke(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stroke(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_stroke) + +static bool js_cc_ICanvasRenderingContext2D_restore(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->restore(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_restore) + +static bool js_cc_ICanvasRenderingContext2D_setShadowBlur(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowBlur(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowBlur) + +static bool js_cc_ICanvasRenderingContext2D_setShadowColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setShadowColor((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowColor) + +static bool js_cc_ICanvasRenderingContext2D_setShadowOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowOffsetX(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowOffsetX) + +static bool js_cc_ICanvasRenderingContext2D_setShadowOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowOffsetY(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setShadowOffsetY) + +static bool js_cc_ICanvasRenderingContext2D_fillImageData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + cc::Data *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::Data temp2 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->fillImageData((cc::Data const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fillImageData) + +static bool js_cc_ICanvasRenderingContext2D_translate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->translate(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_translate) + +static bool js_cc_ICanvasRenderingContext2D_scale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->scale(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_scale) + +static bool js_cc_ICanvasRenderingContext2D_rotate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->rotate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_rotate) + +static bool js_cc_ICanvasRenderingContext2D_transform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->transform(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_transform) + +static bool js_cc_ICanvasRenderingContext2D_setTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTransform(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_setTransform) + +static bool js_cc_ICanvasRenderingContext2D_fetchData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->fetchData(); + + + return true; +} +SE_BIND_FUNC(js_cc_ICanvasRenderingContext2D_fetchData) + +static bool js_cc_ICanvasRenderingContext2D_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_ICanvasRenderingContext2D_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_width_set) + +static bool js_cc_ICanvasRenderingContext2D_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_ICanvasRenderingContext2D_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_height_set) + +static bool js_cc_ICanvasRenderingContext2D_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_ICanvasRenderingContext2D_lineWidth_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineWidth_set) + +static bool js_cc_ICanvasRenderingContext2D_fillStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_fillStyle_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_fillStyle_set) + +static bool js_cc_ICanvasRenderingContext2D_font_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_font_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_font_set) + +static bool js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_globalCompositeOperation_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set) + +static bool js_cc_ICanvasRenderingContext2D_lineCap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_lineCap_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineCap_set) + +static bool js_cc_ICanvasRenderingContext2D_strokeStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_strokeStyle_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_strokeStyle_set) + +static bool js_cc_ICanvasRenderingContext2D_lineJoin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_lineJoin_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_lineJoin_set) + +static bool js_cc_ICanvasRenderingContext2D_textAlign_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_textAlign_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_textAlign_set) + +static bool js_cc_ICanvasRenderingContext2D_textBaseline_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ICanvasRenderingContext2D *arg1 = (cc::ICanvasRenderingContext2D *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_ICanvasRenderingContext2D_textBaseline_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ICanvasRenderingContext2D_textBaseline_set) + +static bool js_delete_cc_ICanvasRenderingContext2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ICanvasRenderingContext2D) + +bool js_register_cc_ICanvasRenderingContext2D(se::Object* obj) { + auto* cls = se::Class::create("ICanvasRenderingContext2D", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", nullptr, _SE(js_cc_ICanvasRenderingContext2D_width_set)); + cls->defineProperty("height", nullptr, _SE(js_cc_ICanvasRenderingContext2D_height_set)); + cls->defineProperty("lineWidth", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineWidth_set)); + cls->defineProperty("fillStyle", nullptr, _SE(js_cc_ICanvasRenderingContext2D_fillStyle_set)); + cls->defineProperty("font", nullptr, _SE(js_cc_ICanvasRenderingContext2D_font_set)); + cls->defineProperty("globalCompositeOperation", nullptr, _SE(js_cc_ICanvasRenderingContext2D_globalCompositeOperation_set)); + cls->defineProperty("lineCap", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineCap_set)); + cls->defineProperty("strokeStyle", nullptr, _SE(js_cc_ICanvasRenderingContext2D_strokeStyle_set)); + cls->defineProperty("lineJoin", nullptr, _SE(js_cc_ICanvasRenderingContext2D_lineJoin_set)); + cls->defineProperty("textAlign", nullptr, _SE(js_cc_ICanvasRenderingContext2D_textAlign_set)); + cls->defineProperty("textBaseline", nullptr, _SE(js_cc_ICanvasRenderingContext2D_textBaseline_set)); + + cls->defineFunction("rect", _SE(js_cc_ICanvasRenderingContext2D_rect)); + cls->defineFunction("clearRect", _SE(js_cc_ICanvasRenderingContext2D_clearRect)); + cls->defineFunction("createLinearGradient", _SE(js_cc_ICanvasRenderingContext2D_createLinearGradient)); + cls->defineFunction("save", _SE(js_cc_ICanvasRenderingContext2D_save)); + cls->defineFunction("beginPath", _SE(js_cc_ICanvasRenderingContext2D_beginPath)); + cls->defineFunction("closePath", _SE(js_cc_ICanvasRenderingContext2D_closePath)); + cls->defineFunction("moveTo", _SE(js_cc_ICanvasRenderingContext2D_moveTo)); + cls->defineFunction("lineTo", _SE(js_cc_ICanvasRenderingContext2D_lineTo)); + cls->defineFunction("fill", _SE(js_cc_ICanvasRenderingContext2D_fill)); + cls->defineFunction("stroke", _SE(js_cc_ICanvasRenderingContext2D_stroke)); + cls->defineFunction("restore", _SE(js_cc_ICanvasRenderingContext2D_restore)); + cls->defineFunction("setShadowBlur", _SE(js_cc_ICanvasRenderingContext2D_setShadowBlur)); + cls->defineFunction("setShadowColor", _SE(js_cc_ICanvasRenderingContext2D_setShadowColor)); + cls->defineFunction("setShadowOffsetX", _SE(js_cc_ICanvasRenderingContext2D_setShadowOffsetX)); + cls->defineFunction("setShadowOffsetY", _SE(js_cc_ICanvasRenderingContext2D_setShadowOffsetY)); + cls->defineFunction("fillImageData", _SE(js_cc_ICanvasRenderingContext2D_fillImageData)); + cls->defineFunction("translate", _SE(js_cc_ICanvasRenderingContext2D_translate)); + cls->defineFunction("scale", _SE(js_cc_ICanvasRenderingContext2D_scale)); + cls->defineFunction("rotate", _SE(js_cc_ICanvasRenderingContext2D_rotate)); + cls->defineFunction("transform", _SE(js_cc_ICanvasRenderingContext2D_transform)); + cls->defineFunction("setTransform", _SE(js_cc_ICanvasRenderingContext2D_setTransform)); + cls->defineFunction("fetchData", _SE(js_cc_ICanvasRenderingContext2D_fetchData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ICanvasRenderingContext2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ICanvasRenderingContext2D_proto = cls->getProto(); + __jsb_cc_ICanvasRenderingContext2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CanvasGradient_class = nullptr; +se::Object* __jsb_cc_CanvasGradient_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CanvasGradient) + +static bool js_new_cc_CanvasGradient(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::CanvasGradient *result; + result = (cc::CanvasGradient *)new cc::CanvasGradient(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CanvasGradient, __jsb_cc_CanvasGradient_class, js_delete_cc_CanvasGradient) + +static bool js_delete_cc_CanvasGradient(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CanvasGradient) + +bool js_register_cc_CanvasGradient(se::Object* obj) { + auto* cls = se::Class::create("CanvasGradient", obj, __jsb_cc_ICanvasGradient_proto, _SE(js_new_cc_CanvasGradient)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CanvasGradient)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CanvasGradient_proto = cls->getProto(); + __jsb_cc_CanvasGradient_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CanvasRenderingContext2D_class = nullptr; +se::Object* __jsb_cc_CanvasRenderingContext2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CanvasRenderingContext2D) + +static bool js_new_cc_CanvasRenderingContext2D(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + float arg2 ; + cc::CanvasRenderingContext2D *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::CanvasRenderingContext2D *)new cc::CanvasRenderingContext2D(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CanvasRenderingContext2D, __jsb_cc_CanvasRenderingContext2D_class, js_delete_cc_CanvasRenderingContext2D) + +static bool js_delete_cc_CanvasRenderingContext2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CanvasRenderingContext2D) + +static bool js_cc_CanvasRenderingContext2D__width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__width_set) + +static bool js_cc_CanvasRenderingContext2D__width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__width_get) + +static bool js_cc_CanvasRenderingContext2D__height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__height_set) + +static bool js_cc_CanvasRenderingContext2D__height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__height_get) + +static bool js_cc_CanvasRenderingContext2D__lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineWidth_set) + +static bool js_cc_CanvasRenderingContext2D__lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lineWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineWidth_get) + +static bool js_cc_CanvasRenderingContext2D__lineJoin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lineJoin, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineJoin_set) + +static bool js_cc_CanvasRenderingContext2D__lineJoin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lineJoin, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_lineJoin, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineJoin_get) + +static bool js_cc_CanvasRenderingContext2D__lineCap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lineCap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__lineCap_set) + +static bool js_cc_CanvasRenderingContext2D__lineCap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lineCap, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_lineCap, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__lineCap_get) + +static bool js_cc_CanvasRenderingContext2D__font_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_font, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__font_set) + +static bool js_cc_CanvasRenderingContext2D__font_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_font, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_font, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__font_get) + +static bool js_cc_CanvasRenderingContext2D__textAlign_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_textAlign, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__textAlign_set) + +static bool js_cc_CanvasRenderingContext2D__textAlign_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_textAlign, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_textAlign, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__textAlign_get) + +static bool js_cc_CanvasRenderingContext2D__textBaseline_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_textBaseline, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__textBaseline_set) + +static bool js_cc_CanvasRenderingContext2D__textBaseline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_textBaseline, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_textBaseline, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__textBaseline_get) + +static bool js_cc_CanvasRenderingContext2D__fillStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fillStyle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__fillStyle_set) + +static bool js_cc_CanvasRenderingContext2D__fillStyle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fillStyle, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_fillStyle, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__fillStyle_get) + +static bool js_cc_CanvasRenderingContext2D__strokeStyle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_strokeStyle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__strokeStyle_set) + +static bool js_cc_CanvasRenderingContext2D__strokeStyle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_strokeStyle, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_strokeStyle, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__strokeStyle_get) + +static bool js_cc_CanvasRenderingContext2D__globalCompositeOperation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_globalCompositeOperation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CanvasRenderingContext2D__globalCompositeOperation_set) + +static bool js_cc_CanvasRenderingContext2D__globalCompositeOperation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CanvasRenderingContext2D *arg1 = (cc::CanvasRenderingContext2D *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_globalCompositeOperation, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_globalCompositeOperation, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CanvasRenderingContext2D__globalCompositeOperation_get) + +bool js_register_cc_CanvasRenderingContext2D(se::Object* obj) { + auto* cls = se::Class::create("CanvasRenderingContext2D", obj, __jsb_cc_ICanvasRenderingContext2D_proto, _SE(js_new_cc_CanvasRenderingContext2D)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_width", _SE(js_cc_CanvasRenderingContext2D__width_get), _SE(js_cc_CanvasRenderingContext2D__width_set)); + cls->defineProperty("_height", _SE(js_cc_CanvasRenderingContext2D__height_get), _SE(js_cc_CanvasRenderingContext2D__height_set)); + cls->defineProperty("_lineWidth", _SE(js_cc_CanvasRenderingContext2D__lineWidth_get), _SE(js_cc_CanvasRenderingContext2D__lineWidth_set)); + cls->defineProperty("_lineJoin", _SE(js_cc_CanvasRenderingContext2D__lineJoin_get), _SE(js_cc_CanvasRenderingContext2D__lineJoin_set)); + cls->defineProperty("_lineCap", _SE(js_cc_CanvasRenderingContext2D__lineCap_get), _SE(js_cc_CanvasRenderingContext2D__lineCap_set)); + cls->defineProperty("_font", _SE(js_cc_CanvasRenderingContext2D__font_get), _SE(js_cc_CanvasRenderingContext2D__font_set)); + cls->defineProperty("_textAlign", _SE(js_cc_CanvasRenderingContext2D__textAlign_get), _SE(js_cc_CanvasRenderingContext2D__textAlign_set)); + cls->defineProperty("_textBaseline", _SE(js_cc_CanvasRenderingContext2D__textBaseline_get), _SE(js_cc_CanvasRenderingContext2D__textBaseline_set)); + cls->defineProperty("_fillStyle", _SE(js_cc_CanvasRenderingContext2D__fillStyle_get), _SE(js_cc_CanvasRenderingContext2D__fillStyle_set)); + cls->defineProperty("_strokeStyle", _SE(js_cc_CanvasRenderingContext2D__strokeStyle_get), _SE(js_cc_CanvasRenderingContext2D__strokeStyle_set)); + cls->defineProperty("_globalCompositeOperation", _SE(js_cc_CanvasRenderingContext2D__globalCompositeOperation_get), _SE(js_cc_CanvasRenderingContext2D__globalCompositeOperation_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CanvasRenderingContext2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CanvasRenderingContext2D_proto = cls->getProto(); + __jsb_cc_CanvasRenderingContext2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Device_class = nullptr; +se::Object* __jsb_cc_Device_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Device) + +static bool js_cc_Device_getDPI_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (int)cc::Device::getDPI(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDPI_static) + +static bool js_cc_Device_getDevicePixelRatio_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::Device::getDevicePixelRatio(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDevicePixelRatio_static) + +static bool js_cc_Device_setAccelerometerEnabled_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::Device::setAccelerometerEnabled(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_setAccelerometerEnabled_static) + +static bool js_cc_Device_setAccelerometerInterval_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::Device::setAccelerometerInterval(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_setAccelerometerInterval_static) + +static bool js_cc_Device_getDeviceOrientation_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IScreen::Orientation result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::IScreen::Orientation)cc::Device::getDeviceOrientation(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDeviceOrientation_static) + +static bool js_cc_Device_getDeviceModel_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = cc::Device::getDeviceModel(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getDeviceModel_static) + +static bool js_cc_Device_setKeepScreenOn_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc::Device::setKeepScreenOn(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_setKeepScreenOn_static) + +static bool js_cc_Device_vibrate_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::Device::vibrate(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_vibrate_static) + +static bool js_cc_Device_getBatteryLevel_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::Device::getBatteryLevel(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getBatteryLevel_static) + +static bool js_cc_Device_getNetworkType_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::INetwork::NetworkType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::INetwork::NetworkType)cc::Device::getNetworkType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getNetworkType_static) + +static bool js_cc_Device_getSafeAreaEdge_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Vec4 result; + cc::Vec4 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = cc::Device::getSafeAreaEdge(); + + temp = ccnew cc::Vec4(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_Device_getSafeAreaEdge_static) + +static bool js_delete_cc_Device(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Device) + +bool js_register_cc_Device(se::Object* obj) { + auto* cls = se::Class::create("Device", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getDPI", _SE(js_cc_Device_getDPI_static)); + cls->defineStaticFunction("getDevicePixelRatio", _SE(js_cc_Device_getDevicePixelRatio_static)); + cls->defineStaticFunction("setAccelerometerEnabled", _SE(js_cc_Device_setAccelerometerEnabled_static)); + cls->defineStaticFunction("setAccelerometerInterval", _SE(js_cc_Device_setAccelerometerInterval_static)); + cls->defineStaticFunction("getDeviceOrientation", _SE(js_cc_Device_getDeviceOrientation_static)); + cls->defineStaticFunction("getDeviceModel", _SE(js_cc_Device_getDeviceModel_static)); + cls->defineStaticFunction("setKeepScreenOn", _SE(js_cc_Device_setKeepScreenOn_static)); + cls->defineStaticFunction("vibrate", _SE(js_cc_Device_vibrate_static)); + cls->defineStaticFunction("getBatteryLevel", _SE(js_cc_Device_getBatteryLevel_static)); + cls->defineStaticFunction("getNetworkType", _SE(js_cc_Device_getNetworkType_static)); + cls->defineStaticFunction("getSafeAreaEdge", _SE(js_cc_Device_getSafeAreaEdge_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Device)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Device_proto = cls->getProto(); + __jsb_cc_Device_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISystemWindow_class = nullptr; +se::Object* __jsb_cc_ISystemWindow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindow) + +static bool js_cc_ISystemWindow_createWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + char *arg2 = (char *) NULL ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + int arg7 ; + ccstd::string temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->createWindow((char const *)arg2,arg3,arg4,arg5,arg6,arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_ISystemWindow_createWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + char *arg2 = (char *) NULL ; + int arg3 ; + int arg4 ; + int arg5 ; + ccstd::string temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + 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 = (bool)(arg1)->createWindow((char const *)arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_ISystemWindow_createWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_ISystemWindow_createWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_ISystemWindow_createWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_ISystemWindow_createWindow) + +static bool js_cc_ISystemWindow_getWindowId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ISystemWindow const *)arg1)->getWindowId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_getWindowId) + +static bool js_cc_ISystemWindow_closeWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->closeWindow(); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_closeWindow) + +static bool js_cc_ISystemWindow_getWindowHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + uintptr_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ISystemWindow const *)arg1)->getWindowHandle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_getWindowHandle) + +static bool js_cc_ISystemWindow_getViewSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + cc::ISystemWindow::Size result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::ISystemWindow const *)arg1)->getViewSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_getViewSize) + +static bool js_cc_ISystemWindow_setViewSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setViewSize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_setViewSize) + +static bool js_cc_ISystemWindow_setCursorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindow *arg1 = (cc::ISystemWindow *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCursorEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindow_setCursorEnabled) + +static bool js_delete_cc_ISystemWindow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindow) + +bool js_register_cc_ISystemWindow(se::Object* obj) { + auto* cls = se::Class::create("ISystemWindow", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("createWindow", _SE(js_cc_ISystemWindow_createWindow)); + cls->defineFunction("getWindowId", _SE(js_cc_ISystemWindow_getWindowId)); + cls->defineFunction("closeWindow", _SE(js_cc_ISystemWindow_closeWindow)); + cls->defineFunction("getWindowHandle", _SE(js_cc_ISystemWindow_getWindowHandle)); + cls->defineFunction("getViewSize", _SE(js_cc_ISystemWindow_getViewSize)); + cls->defineFunction("setViewSize", _SE(js_cc_ISystemWindow_setViewSize)); + cls->defineFunction("setCursorEnabled", _SE(js_cc_ISystemWindow_setCursorEnabled)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISystemWindow_proto = cls->getProto(); + __jsb_cc_ISystemWindow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISystemWindowInfo_class = nullptr; +se::Object* __jsb_cc_ISystemWindowInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindowInfo) + +static bool js_cc_ISystemWindowInfo_title_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->title, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_title_set) + +static bool js_cc_ISystemWindowInfo_title_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->title, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->title, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_title_get) + +static bool js_cc_ISystemWindowInfo_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_x_set) + +static bool js_cc_ISystemWindowInfo_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_x_get) + +static bool js_cc_ISystemWindowInfo_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_y_set) + +static bool js_cc_ISystemWindowInfo_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_y_get) + +static bool js_cc_ISystemWindowInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_width_set) + +static bool js_cc_ISystemWindowInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_width_get) + +static bool js_cc_ISystemWindowInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_height_set) + +static bool js_cc_ISystemWindowInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_height_get) + +static bool js_cc_ISystemWindowInfo_flags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_flags_set) + +static bool js_cc_ISystemWindowInfo_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_flags_get) + +static bool js_cc_ISystemWindowInfo_externalHandle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->externalHandle); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_ISystemWindowInfo_externalHandle_set) + +static bool js_cc_ISystemWindowInfo_externalHandle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::ISystemWindowInfo *arg1 = (cc::ISystemWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalHandle, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalHandle, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_ISystemWindowInfo_externalHandle_get) + +static bool js_new_cc_ISystemWindowInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ISystemWindowInfo *result; + result = (cc::ISystemWindowInfo *)new cc::ISystemWindowInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ISystemWindowInfo, __jsb_cc_ISystemWindowInfo_class, js_delete_cc_ISystemWindowInfo) + +static bool js_delete_cc_ISystemWindowInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindowInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISystemWindowInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("title", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->title), ctx); + } + + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("flags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flags), ctx); + } + + + json->getProperty("externalHandle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalHandle), ctx); + } + + + return ok; +} + + +bool js_register_cc_ISystemWindowInfo(se::Object* obj) { + auto* cls = se::Class::create("ISystemWindowInfo", obj, nullptr, _SE(js_new_cc_ISystemWindowInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("title", _SE(js_cc_ISystemWindowInfo_title_get), _SE(js_cc_ISystemWindowInfo_title_set)); + cls->defineProperty("x", _SE(js_cc_ISystemWindowInfo_x_get), _SE(js_cc_ISystemWindowInfo_x_set)); + cls->defineProperty("y", _SE(js_cc_ISystemWindowInfo_y_get), _SE(js_cc_ISystemWindowInfo_y_set)); + cls->defineProperty("width", _SE(js_cc_ISystemWindowInfo_width_get), _SE(js_cc_ISystemWindowInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_ISystemWindowInfo_height_get), _SE(js_cc_ISystemWindowInfo_height_set)); + cls->defineProperty("flags", _SE(js_cc_ISystemWindowInfo_flags_get), _SE(js_cc_ISystemWindowInfo_flags_set)); + cls->defineProperty("externalHandle", _SE(js_cc_ISystemWindowInfo_externalHandle_get), _SE(js_cc_ISystemWindowInfo_externalHandle_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindowInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISystemWindowInfo_proto = cls->getProto(); + __jsb_cc_ISystemWindowInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_ISystemWindowManager_class = nullptr; +se::Object* __jsb_cc_ISystemWindowManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ISystemWindowManager) + +static bool js_cc_ISystemWindowManager_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->init(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindowManager_init) + +static bool js_cc_ISystemWindowManager_processEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->processEvent(); + + + return true; +} +SE_BIND_FUNC(js_cc_ISystemWindowManager_processEvent) + +static bool js_cc_ISystemWindowManager_createWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + cc::ISystemWindowInfo *arg2 = 0 ; + cc::ISystemWindowInfo temp2 ; + cc::ISystemWindow *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(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::ISystemWindow *)(arg1)->createWindow((cc::ISystemWindowInfo 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_ISystemWindowManager_createWindow) + +static bool js_cc_ISystemWindowManager_getWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + uint32_t arg2 ; + cc::ISystemWindow *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::ISystemWindow *)((cc::ISystemWindowManager const *)arg1)->getWindow(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_ISystemWindowManager_getWindow) + +static bool js_cc_ISystemWindowManager_getWindows(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowManager *arg1 = (cc::ISystemWindowManager *) NULL ; + cc::SystemWindowMap *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(s); + if (nullptr == arg1) return true; + result = (cc::SystemWindowMap *) &((cc::ISystemWindowManager const *)arg1)->getWindows(); + + 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_ISystemWindowManager_getWindows) + +static bool js_delete_cc_ISystemWindowManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ISystemWindowManager) + +bool js_register_cc_ISystemWindowManager(se::Object* obj) { + auto* cls = se::Class::create("ISystemWindowManager", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("init", _SE(js_cc_ISystemWindowManager_init)); + cls->defineFunction("processEvent", _SE(js_cc_ISystemWindowManager_processEvent)); + cls->defineFunction("createWindow", _SE(js_cc_ISystemWindowManager_createWindow)); + cls->defineFunction("getWindow", _SE(js_cc_ISystemWindowManager_getWindow)); + cls->defineFunction("getWindows", _SE(js_cc_ISystemWindowManager_getWindows)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ISystemWindowManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ISystemWindowManager_proto = cls->getProto(); + __jsb_cc_ISystemWindowManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_FileUtils_class = nullptr; +se::Object* __jsb_cc_FileUtils_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_FileUtils) + +static bool js_cc_FileUtils_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::FileUtils *)cc::FileUtils::getInstance(); + + 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_FileUtils_getInstance_static) + +static bool js_delete_cc_FileUtils(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_FileUtils) + +static bool js_cc_FileUtils_purgeCachedEntries(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->purgeCachedEntries(); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_purgeCachedEntries) + +static bool js_cc_FileUtils_getStringFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getStringFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getStringFromFile) + +static bool js_cc_FileUtils_getDataFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Data result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getDataFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getDataFromFile) + +static bool js_cc_FileUtils_getFileDataFromZip(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + uint32_t *arg4 = (uint32_t *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + unsigned char *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (unsigned char *)(arg1)->getFileDataFromZip((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileDataFromZip) + +static bool js_cc_FileUtils_fullPathForFilename(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->fullPathForFilename((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_fullPathForFilename) + +static bool js_cc_FileUtils_fullPathFromRelativeFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + ccstd::string result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (arg1)->fullPathFromRelativeFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_fullPathFromRelativeFile) + +static bool js_cc_FileUtils_setSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::vector< ccstd::string > *arg2 = 0 ; + ccstd::vector< ccstd::string > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSearchPaths((ccstd::vector< ccstd::string > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_setSearchPaths) + +static bool js_cc_FileUtils_getDefaultResourceRootPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *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(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &((cc::FileUtils const *)arg1)->getDefaultResourceRootPath(); + + 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_FileUtils_getDefaultResourceRootPath) + +static bool js_cc_FileUtils_setDefaultResourceRootPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDefaultResourceRootPath((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_setDefaultResourceRootPath) + +static bool js_cc_FileUtils_addSearchPath__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + bool arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSearchPath((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_FileUtils_addSearchPath__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSearchPath((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_FileUtils_addSearchPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_FileUtils_addSearchPath__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_FileUtils_addSearchPath__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_FileUtils_addSearchPath) + +static bool js_cc_FileUtils_getSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::vector< ccstd::string > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &((cc::FileUtils const *)arg1)->getSearchPaths(); + + 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_FileUtils_getSearchPaths) + +static bool js_cc_FileUtils_getOriginalSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::vector< ccstd::string > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< ccstd::string > *) &((cc::FileUtils const *)arg1)->getOriginalSearchPaths(); + + 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_FileUtils_getOriginalSearchPaths) + +static bool js_cc_FileUtils_getWritablePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::FileUtils const *)arg1)->getWritablePath(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getWritablePath) + +static bool js_cc_FileUtils_setWritablePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setWritablePath((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_setWritablePath) + +static bool js_cc_FileUtils_getValueMapFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::ValueMap result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getValueMapFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getValueMapFromFile) + +static bool js_cc_FileUtils_getValueMapFromData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + char *arg2 = (char *) NULL ; + int arg3 ; + ccstd::string temp2 ; + cc::ValueMap result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getValueMapFromData((char const *)arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getValueMapFromData) + +static bool js_cc_FileUtils_writeToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::ValueMap *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::ValueMap temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeToFile((cc::ValueMap const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeToFile) + +static bool js_cc_FileUtils_writeStringToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeStringToFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeStringToFile) + +static bool js_cc_FileUtils_writeDataToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::Data *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::Data temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeDataToFile((cc::Data const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeDataToFile) + +static bool js_cc_FileUtils_writeValueMapToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::ValueMap *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::ValueMap temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeValueMapToFile((cc::ValueMap const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeValueMapToFile) + +static bool js_cc_FileUtils_writeValueVectorToFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + cc::ValueVector *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + cc::ValueVector temp2 ; + ccstd::string temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->writeValueVectorToFile((cc::ValueVector const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_writeValueVectorToFile) + +static bool js_cc_FileUtils_getSuitableFOpen(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->getSuitableFOpen((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getSuitableFOpen) + +static bool js_cc_FileUtils_getValueVectorFromFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::ValueVector result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getValueVectorFromFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getValueVectorFromFile) + +static bool js_cc_FileUtils_isFileExist(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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::FileUtils const *)arg1)->isFileExist((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_isFileExist) + +static bool js_cc_FileUtils_getFileExtension(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->getFileExtension((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileExtension) + +static bool js_cc_FileUtils_isAbsolutePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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::FileUtils const *)arg1)->isAbsolutePath((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_isAbsolutePath) + +static bool js_cc_FileUtils_isDirectoryExist(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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::FileUtils const *)arg1)->isDirectoryExist((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_isDirectoryExist) + +static bool js_cc_FileUtils_listFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::vector< ccstd::string > result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->listFiles((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_listFiles) + +static bool js_cc_FileUtils_createDirectory(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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)(arg1)->createDirectory((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_createDirectory) + +static bool js_cc_FileUtils_removeDirectory(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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)(arg1)->removeDirectory((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_removeDirectory) + +static bool js_cc_FileUtils_removeFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) 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(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)(arg1)->removeFile((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_removeFile) + +static bool js_cc_FileUtils_renameFile__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + ccstd::string temp4 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (bool)(arg1)->renameFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_FileUtils_renameFile__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->renameFile((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_FileUtils_renameFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_FileUtils_renameFile__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_FileUtils_renameFile__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_FileUtils_renameFile) + +static bool js_cc_FileUtils_getFileSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + long result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (long)(arg1)->getFileSize((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileSize) + +static bool js_cc_FileUtils_normalizePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->normalizePath((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_normalizePath) + +static bool js_cc_FileUtils_getFileDir(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *arg1 = (cc::FileUtils *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + ccstd::string result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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::FileUtils const *)arg1)->getFileDir((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_FileUtils_getFileDir) + +bool js_register_cc_FileUtils(se::Object* obj) { + auto* cls = se::Class::create("FileUtils", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("purgeCachedEntries", _SE(js_cc_FileUtils_purgeCachedEntries)); + cls->defineFunction("getStringFromFile", _SE(js_cc_FileUtils_getStringFromFile)); + cls->defineFunction("getDataFromFile", _SE(js_cc_FileUtils_getDataFromFile)); + cls->defineFunction("getFileDataFromZip", _SE(js_cc_FileUtils_getFileDataFromZip)); + cls->defineFunction("fullPathForFilename", _SE(js_cc_FileUtils_fullPathForFilename)); + cls->defineFunction("fullPathFromRelativeFile", _SE(js_cc_FileUtils_fullPathFromRelativeFile)); + cls->defineFunction("setSearchPaths", _SE(js_cc_FileUtils_setSearchPaths)); + cls->defineFunction("getDefaultResourceRootPath", _SE(js_cc_FileUtils_getDefaultResourceRootPath)); + cls->defineFunction("setDefaultResourceRootPath", _SE(js_cc_FileUtils_setDefaultResourceRootPath)); + cls->defineFunction("addSearchPath", _SE(js_cc_FileUtils_addSearchPath)); + cls->defineFunction("getSearchPaths", _SE(js_cc_FileUtils_getSearchPaths)); + cls->defineFunction("getOriginalSearchPaths", _SE(js_cc_FileUtils_getOriginalSearchPaths)); + cls->defineFunction("getWritablePath", _SE(js_cc_FileUtils_getWritablePath)); + cls->defineFunction("setWritablePath", _SE(js_cc_FileUtils_setWritablePath)); + cls->defineFunction("getValueMapFromFile", _SE(js_cc_FileUtils_getValueMapFromFile)); + cls->defineFunction("getValueMapFromData", _SE(js_cc_FileUtils_getValueMapFromData)); + cls->defineFunction("writeToFile", _SE(js_cc_FileUtils_writeToFile)); + cls->defineFunction("writeStringToFile", _SE(js_cc_FileUtils_writeStringToFile)); + cls->defineFunction("writeDataToFile", _SE(js_cc_FileUtils_writeDataToFile)); + cls->defineFunction("writeValueMapToFile", _SE(js_cc_FileUtils_writeValueMapToFile)); + cls->defineFunction("writeValueVectorToFile", _SE(js_cc_FileUtils_writeValueVectorToFile)); + cls->defineFunction("getSuitableFOpen", _SE(js_cc_FileUtils_getSuitableFOpen)); + cls->defineFunction("getValueVectorFromFile", _SE(js_cc_FileUtils_getValueVectorFromFile)); + cls->defineFunction("isFileExist", _SE(js_cc_FileUtils_isFileExist)); + cls->defineFunction("getFileExtension", _SE(js_cc_FileUtils_getFileExtension)); + cls->defineFunction("isAbsolutePath", _SE(js_cc_FileUtils_isAbsolutePath)); + cls->defineFunction("isDirectoryExist", _SE(js_cc_FileUtils_isDirectoryExist)); + cls->defineFunction("listFiles", _SE(js_cc_FileUtils_listFiles)); + cls->defineFunction("createDirectory", _SE(js_cc_FileUtils_createDirectory)); + cls->defineFunction("removeDirectory", _SE(js_cc_FileUtils_removeDirectory)); + cls->defineFunction("removeFile", _SE(js_cc_FileUtils_removeFile)); + cls->defineFunction("renameFile", _SE(js_cc_FileUtils_renameFile)); + cls->defineFunction("getFileSize", _SE(js_cc_FileUtils_getFileSize)); + cls->defineFunction("normalizePath", _SE(js_cc_FileUtils_normalizePath)); + cls->defineFunction("getFileDir", _SE(js_cc_FileUtils_getFileDir)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_FileUtils_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_FileUtils)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_FileUtils_proto = cls->getProto(); + __jsb_cc_FileUtils_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_createFileUtils(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::FileUtils *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::FileUtils *)cc::createFileUtils(); + + 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_createFileUtils) + +se::Class* __jsb_cc_SAXParser_class = nullptr; +se::Object* __jsb_cc_SAXParser_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SAXParser) + +static bool js_new_cc_SAXParser(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SAXParser *result; + result = (cc::SAXParser *)new cc::SAXParser(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SAXParser, __jsb_cc_SAXParser_class, js_delete_cc_SAXParser) + +static bool js_delete_cc_SAXParser(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SAXParser) + +static bool js_cc_PlistParser_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SAXParser *arg1 = (cc::SAXParser *) NULL ; + char *arg2 = (char *) NULL ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + result = (bool)(arg1)->init((char const *)arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_PlistParser_init) + +static bool js_cc_PlistParser_parse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SAXParser *arg1 = (cc::SAXParser *) 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(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)(arg1)->parse((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_PlistParser_parse) + +bool js_register_cc_SAXParser(se::Object* obj) { + auto* cls = se::Class::create("PlistParser", obj, nullptr, _SE(js_new_cc_SAXParser)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("init", _SE(js_cc_PlistParser_init)); + cls->defineFunction("parse", _SE(js_cc_PlistParser_parse)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SAXParser)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SAXParser_proto = cls->getProto(); + __jsb_cc_SAXParser_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#if CC_USE_DEBUG_RENDERER + +se::Class* __jsb_cc_DebugTextInfo_class = nullptr; +se::Object* __jsb_cc_DebugTextInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DebugTextInfo) + +static bool js_new_cc_DebugTextInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DebugTextInfo *result; + result = (cc::DebugTextInfo *)new cc::DebugTextInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DebugTextInfo, __jsb_cc_DebugTextInfo_class, js_delete_cc_DebugTextInfo) + +static bool js_cc_DebugTextInfo_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_color_set) + +static bool js_cc_DebugTextInfo_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_color_get) + +static bool js_cc_DebugTextInfo_bold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bold); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_bold_set) + +static bool js_cc_DebugTextInfo_bold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bold, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_bold_get) + +static bool js_cc_DebugTextInfo_italic_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->italic); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_italic_set) + +static bool js_cc_DebugTextInfo_italic_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->italic, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_italic_get) + +static bool js_cc_DebugTextInfo_shadow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadow); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadow_set) + +static bool js_cc_DebugTextInfo_shadow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadow, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadow_get) + +static bool js_cc_DebugTextInfo_shadowThickness_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadowThickness, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadowThickness_set) + +static bool js_cc_DebugTextInfo_shadowThickness_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadowThickness, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadowThickness_get) + +static bool js_cc_DebugTextInfo_shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadowColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_shadowColor_set) + +static bool js_cc_DebugTextInfo_shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadowColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shadowColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_shadowColor_get) + +static bool js_cc_DebugTextInfo_scale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_DebugTextInfo_scale_set) + +static bool js_cc_DebugTextInfo_scale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::DebugTextInfo *arg1 = (cc::DebugTextInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_DebugTextInfo_scale_get) + +static bool js_delete_cc_DebugTextInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DebugTextInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::DebugTextInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("color", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->color), ctx); + } + + + json->getProperty("bold", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bold), ctx); + } + + + json->getProperty("italic", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->italic), ctx); + } + + + json->getProperty("shadow", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadow), ctx); + } + + + json->getProperty("shadowThickness", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadowThickness), ctx); + } + + + json->getProperty("shadowColor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadowColor), ctx); + } + + + json->getProperty("scale", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->scale), ctx); + } + + + return ok; +} + + +bool js_register_cc_DebugTextInfo(se::Object* obj) { + auto* cls = se::Class::create("DebugTextInfo", obj, nullptr, _SE(js_new_cc_DebugTextInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("color", _SE(js_cc_DebugTextInfo_color_get), _SE(js_cc_DebugTextInfo_color_set)); + cls->defineProperty("bold", _SE(js_cc_DebugTextInfo_bold_get), _SE(js_cc_DebugTextInfo_bold_set)); + cls->defineProperty("italic", _SE(js_cc_DebugTextInfo_italic_get), _SE(js_cc_DebugTextInfo_italic_set)); + cls->defineProperty("shadow", _SE(js_cc_DebugTextInfo_shadow_get), _SE(js_cc_DebugTextInfo_shadow_set)); + cls->defineProperty("shadowThickness", _SE(js_cc_DebugTextInfo_shadowThickness_get), _SE(js_cc_DebugTextInfo_shadowThickness_set)); + cls->defineProperty("shadowColor", _SE(js_cc_DebugTextInfo_shadowColor_get), _SE(js_cc_DebugTextInfo_shadowColor_set)); + cls->defineProperty("scale", _SE(js_cc_DebugTextInfo_scale_get), _SE(js_cc_DebugTextInfo_scale_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DebugTextInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DebugTextInfo_proto = cls->getProto(); + __jsb_cc_DebugTextInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#endif // CC_USE_DEBUG_RENDERER +#if CC_USE_DEBUG_RENDERER + +se::Class* __jsb_cc_DebugRenderer_class = nullptr; +se::Object* __jsb_cc_DebugRenderer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_DebugRenderer) + +static bool js_cc_DebugRenderer_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::DebugRenderer *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::DebugRenderer *)cc::DebugRenderer::getInstance(); + + 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_DebugRenderer_getInstance_static) + +static bool js_new_cc_DebugRenderer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::DebugRenderer *result; + result = (cc::DebugRenderer *)new cc::DebugRenderer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_DebugRenderer, __jsb_cc_DebugRenderer_class, js_delete_cc_DebugRenderer) + +static bool js_delete_cc_DebugRenderer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_DebugRenderer) + +static bool js_cc_DebugRenderer_addText__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::DebugRenderer *arg1 = (cc::DebugRenderer *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->addText((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3); + + + return true; +} + +static bool js_cc_DebugRenderer_addText__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::DebugRenderer *arg1 = (cc::DebugRenderer *) NULL ; + ccstd::string *arg2 = 0 ; + cc::Vec2 *arg3 = 0 ; + cc::DebugTextInfo *arg4 = 0 ; + ccstd::string temp2 ; + cc::Vec2 temp3 ; + cc::DebugTextInfo temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addText((ccstd::string const &)*arg2,(cc::Vec2 const &)*arg3,(cc::DebugTextInfo const &)*arg4); + + + return true; +} + +static bool js_cc_DebugRenderer_addText(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_DebugRenderer_addText__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_DebugRenderer_addText__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_DebugRenderer_addText) + +bool js_register_cc_DebugRenderer(se::Object* obj) { + auto* cls = se::Class::create("DebugRenderer", obj, nullptr, _SE(js_new_cc_DebugRenderer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addText", _SE(js_cc_DebugRenderer_addText)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_DebugRenderer_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_DebugRenderer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_DebugRenderer_proto = cls->getProto(); + __jsb_cc_DebugRenderer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#endif // CC_USE_DEBUG_RENDERER + + + +bool register_all_engine(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_Vec2(ns); + js_register_cc_Color(ns); + js_register_cc_Vec3(ns); + js_register_cc_Vec4(ns); + js_register_cc_Mat3(ns); + js_register_cc_Mat4(ns); + js_register_cc_Quaternion(ns); + js_register_cc_CCObject(ns); + js_register_cc_JSBNativeDataHolder(ns); + js_register_cc_ICanvasGradient(ns); + js_register_cc_ICanvasRenderingContext2D(ns); + js_register_cc_CanvasGradient(ns); + js_register_cc_CanvasRenderingContext2D(ns); + js_register_cc_Device(ns); + js_register_cc_ISystemWindow(ns); + js_register_cc_ISystemWindowInfo(ns); + js_register_cc_ISystemWindowManager(ns); + js_register_cc_FileUtils(ns); + js_register_cc_SAXParser(ns); +#if CC_USE_DEBUG_RENDERER + js_register_cc_DebugTextInfo(ns); +#endif // CC_USE_DEBUG_RENDERER +#if CC_USE_DEBUG_RENDERER + js_register_cc_DebugRenderer(ns); +#endif // CC_USE_DEBUG_RENDERER + + /* 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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_cocos_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_cocos_auto.h new file mode 100644 index 0000000000..a0e636f194 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_cocos_auto.h @@ -0,0 +1,176 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "core/data/Object.h" +#include "core/data/JSBNativeDataHolder.h" +#include "platform/interfaces/modules/canvas/CanvasRenderingContext2D.h" +#include "platform/interfaces/modules/Device.h" +#include "platform/interfaces/modules/ISystemWindow.h" +#include "platform/interfaces/modules/ISystemWindowManager.h" +#include "platform/FileUtils.h" +#include "platform/SAXParser.h" +#include "math/Vec2.h" +#include "math/Vec3.h" +#include "math/Vec4.h" +#include "math/Mat3.h" +#include "math/Mat4.h" +#include "math/Quaternion.h" +#include "math/Color.h" +#include "profiler/DebugRenderer.h" + + + +bool register_all_engine(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::Vec2); +extern se::Object *__jsb_cc_Vec2_proto; // NOLINT +extern se::Class * __jsb_cc_Vec2_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Color); +extern se::Object *__jsb_cc_Color_proto; // NOLINT +extern se::Class * __jsb_cc_Color_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Vec3); +extern se::Object *__jsb_cc_Vec3_proto; // NOLINT +extern se::Class * __jsb_cc_Vec3_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Vec4); +extern se::Object *__jsb_cc_Vec4_proto; // NOLINT +extern se::Class * __jsb_cc_Vec4_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Mat3); +extern se::Object *__jsb_cc_Mat3_proto; // NOLINT +extern se::Class * __jsb_cc_Mat3_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Mat4); +extern se::Object *__jsb_cc_Mat4_proto; // NOLINT +extern se::Class * __jsb_cc_Mat4_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Quaternion); +extern se::Object *__jsb_cc_Quaternion_proto; // NOLINT +extern se::Class * __jsb_cc_Quaternion_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CCObject); +extern se::Object *__jsb_cc_CCObject_proto; // NOLINT +extern se::Class * __jsb_cc_CCObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::JSBNativeDataHolder); +extern se::Object *__jsb_cc_JSBNativeDataHolder_proto; // NOLINT +extern se::Class * __jsb_cc_JSBNativeDataHolder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ICanvasGradient); +extern se::Object *__jsb_cc_ICanvasGradient_proto; // NOLINT +extern se::Class * __jsb_cc_ICanvasGradient_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ICanvasRenderingContext2D); +extern se::Object *__jsb_cc_ICanvasRenderingContext2D_proto; // NOLINT +extern se::Class * __jsb_cc_ICanvasRenderingContext2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CanvasGradient); +extern se::Object *__jsb_cc_CanvasGradient_proto; // NOLINT +extern se::Class * __jsb_cc_CanvasGradient_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CanvasRenderingContext2D); +extern se::Object *__jsb_cc_CanvasRenderingContext2D_proto; // NOLINT +extern se::Class * __jsb_cc_CanvasRenderingContext2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Device); +extern se::Object *__jsb_cc_Device_proto; // NOLINT +extern se::Class * __jsb_cc_Device_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ISystemWindow); +extern se::Object *__jsb_cc_ISystemWindow_proto; // NOLINT +extern se::Class * __jsb_cc_ISystemWindow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::ISystemWindowInfo); +extern se::Object *__jsb_cc_ISystemWindowInfo_proto; // NOLINT +extern se::Class * __jsb_cc_ISystemWindowInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::ISystemWindowInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ISystemWindowManager); +extern se::Object *__jsb_cc_ISystemWindowManager_proto; // NOLINT +extern se::Class * __jsb_cc_ISystemWindowManager_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::FileUtils); +extern se::Object *__jsb_cc_FileUtils_proto; // NOLINT +extern se::Class * __jsb_cc_FileUtils_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SAXParser); +extern se::Object *__jsb_cc_SAXParser_proto; // NOLINT +extern se::Class * __jsb_cc_SAXParser_class; // NOLINT + +#if CC_USE_DEBUG_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::DebugTextInfo); +extern se::Object *__jsb_cc_DebugTextInfo_proto; // NOLINT +extern se::Class * __jsb_cc_DebugTextInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::DebugTextInfo * to, se::Object *ctx); + +#endif // CC_USE_DEBUG_RENDERER +#if CC_USE_DEBUG_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::DebugRenderer); +extern se::Object *__jsb_cc_DebugRenderer_proto; // NOLINT +extern se::Class * __jsb_cc_DebugRenderer_class; // NOLINT + +#endif // CC_USE_DEBUG_RENDERER +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_dragonbones_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_dragonbones_auto.cpp new file mode 100644 index 0000000000..1a35380f30 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_dragonbones_auto.cpp @@ -0,0 +1,13634 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_2d_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_dragonbones_auto.h" + + + +se::Class* __jsb_dragonBones_Rectangle_class = nullptr; +se::Object* __jsb_dragonBones_Rectangle_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Rectangle) + +static bool js_dragonBones_Rectangle_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_x_set) + +static bool js_dragonBones_Rectangle_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_x_get) + +static bool js_dragonBones_Rectangle_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_y_set) + +static bool js_dragonBones_Rectangle_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_y_get) + +static bool js_dragonBones_Rectangle_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_width_set) + +static bool js_dragonBones_Rectangle_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_width_get) + +static bool js_dragonBones_Rectangle_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Rectangle_height_set) + +static bool js_dragonBones_Rectangle_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Rectangle_height_get) + +static bool js_new_dragonBones_Rectangle__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + dragonBones::Rectangle *result; + result = (dragonBones::Rectangle *)new dragonBones::Rectangle(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_dragonBones_Rectangle__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + dragonBones::Rectangle *arg1 = 0 ; + dragonBones::Rectangle temp1 ; + dragonBones::Rectangle *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (dragonBones::Rectangle *)new dragonBones::Rectangle((dragonBones::Rectangle const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_dragonBones_Rectangle(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_dragonBones_Rectangle__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_dragonBones_Rectangle__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Rectangle"); + return false; +} +SE_BIND_CTOR(js_new_dragonBones_Rectangle, __jsb_dragonBones_Rectangle_class, js_delete_dragonBones_Rectangle) + +static bool js_delete_dragonBones_Rectangle(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Rectangle) + +static bool js_dragonBones_Rectangle_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *arg1 = (dragonBones::Rectangle *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Rectangle_clear) + +bool js_register_dragonBones_Rectangle(se::Object* obj) { + auto* cls = se::Class::create("Rectangle", obj, nullptr, _SE(js_new_dragonBones_Rectangle)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_dragonBones_Rectangle_x_get), _SE(js_dragonBones_Rectangle_x_set)); + cls->defineProperty("y", _SE(js_dragonBones_Rectangle_y_get), _SE(js_dragonBones_Rectangle_y_set)); + cls->defineProperty("width", _SE(js_dragonBones_Rectangle_width_get), _SE(js_dragonBones_Rectangle_width_set)); + cls->defineProperty("height", _SE(js_dragonBones_Rectangle_height_get), _SE(js_dragonBones_Rectangle_height_set)); + + cls->defineFunction("clear", _SE(js_dragonBones_Rectangle_clear)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Rectangle)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Rectangle_proto = cls->getProto(); + __jsb_dragonBones_Rectangle_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Transform_class = nullptr; +se::Object* __jsb_dragonBones_Transform_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Transform) + +static bool js_dragonBones_Transform_normalizeRadian_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)dragonBones::Transform::normalizeRadian(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Transform_normalizeRadian_static) + +static bool js_dragonBones_Transform_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_x_set) + +static bool js_dragonBones_Transform_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_x_get) + +static bool js_dragonBones_Transform_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_y_set) + +static bool js_dragonBones_Transform_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_y_get) + +static bool js_dragonBones_Transform_skew_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->skew, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_skew_set) + +static bool js_dragonBones_Transform_skew_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->skew, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_skew_get) + +static bool js_dragonBones_Transform_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rotation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_rotation_set) + +static bool js_dragonBones_Transform_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rotation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_rotation_get) + +static bool js_dragonBones_Transform_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scaleX, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_scaleX_set) + +static bool js_dragonBones_Transform_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scaleX, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_scaleX_get) + +static bool js_dragonBones_Transform_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scaleY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Transform_scaleY_set) + +static bool js_dragonBones_Transform_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Transform *arg1 = (dragonBones::Transform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scaleY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Transform_scaleY_get) + +static bool js_delete_dragonBones_Transform(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Transform) + +bool js_register_dragonBones_Transform(se::Object* obj) { + auto* cls = se::Class::create("Transform", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_dragonBones_Transform_x_get), _SE(js_dragonBones_Transform_x_set)); + cls->defineProperty("y", _SE(js_dragonBones_Transform_y_get), _SE(js_dragonBones_Transform_y_set)); + cls->defineProperty("skew", _SE(js_dragonBones_Transform_skew_get), _SE(js_dragonBones_Transform_skew_set)); + cls->defineProperty("rotation", _SE(js_dragonBones_Transform_rotation_get), _SE(js_dragonBones_Transform_rotation_set)); + cls->defineProperty("scaleX", _SE(js_dragonBones_Transform_scaleX_get), _SE(js_dragonBones_Transform_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_dragonBones_Transform_scaleY_get), _SE(js_dragonBones_Transform_scaleY_set)); + + + + cls->defineStaticFunction("normalizeRadian", _SE(js_dragonBones_Transform_normalizeRadian_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Transform)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Transform_proto = cls->getProto(); + __jsb_dragonBones_Transform_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Matrix_class = nullptr; +se::Object* __jsb_dragonBones_Matrix_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Matrix) + +static bool js_dragonBones_Matrix_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_a_set) + +static bool js_dragonBones_Matrix_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_a_get) + +static bool js_dragonBones_Matrix_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_b_set) + +static bool js_dragonBones_Matrix_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_b_get) + +static bool js_dragonBones_Matrix_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_c_set) + +static bool js_dragonBones_Matrix_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_c_get) + +static bool js_dragonBones_Matrix_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->d, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_d_set) + +static bool js_dragonBones_Matrix_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->d, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_d_get) + +static bool js_dragonBones_Matrix_tx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tx, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_tx_set) + +static bool js_dragonBones_Matrix_tx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tx, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_tx_get) + +static bool js_dragonBones_Matrix_ty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ty, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Matrix_ty_set) + +static bool js_dragonBones_Matrix_ty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Matrix *arg1 = (dragonBones::Matrix *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Matrix_ty_get) + +static bool js_delete_dragonBones_Matrix(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Matrix) + +bool js_register_dragonBones_Matrix(se::Object* obj) { + auto* cls = se::Class::create("Matrix", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("a", _SE(js_dragonBones_Matrix_a_get), _SE(js_dragonBones_Matrix_a_set)); + cls->defineProperty("b", _SE(js_dragonBones_Matrix_b_get), _SE(js_dragonBones_Matrix_b_set)); + cls->defineProperty("c", _SE(js_dragonBones_Matrix_c_get), _SE(js_dragonBones_Matrix_c_set)); + cls->defineProperty("d", _SE(js_dragonBones_Matrix_d_get), _SE(js_dragonBones_Matrix_d_set)); + cls->defineProperty("tx", _SE(js_dragonBones_Matrix_tx_get), _SE(js_dragonBones_Matrix_tx_set)); + cls->defineProperty("ty", _SE(js_dragonBones_Matrix_ty_get), _SE(js_dragonBones_Matrix_ty_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Matrix)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Matrix_proto = cls->getProto(); + __jsb_dragonBones_Matrix_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BaseObject_class = nullptr; +se::Object* __jsb_dragonBones_BaseObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BaseObject) + +static bool js_dragonBones_BaseObject_setMaxCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::size_t arg1 ; + unsigned int arg2 ; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + dragonBones::BaseObject::setMaxCount(SWIG_STD_MOVE(arg1),arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseObject_setMaxCount_static) + +static bool js_dragonBones_BaseObject_clearPool_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::size_t arg1 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + dragonBones::BaseObject::clearPool(SWIG_STD_MOVE(arg1)); + + + return true; +} + +static bool js_dragonBones_BaseObject_clearPool_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + + dragonBones::BaseObject::clearPool(); + + + return true; +} + +static bool js_dragonBones_BaseObject_clearPool_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_dragonBones_BaseObject_clearPool_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_BaseObject_clearPool_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseObject_clearPool_static) + +static bool js_dragonBones_BaseObject_hashCode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BaseObject *arg1 = (dragonBones::BaseObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hashCode, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BaseObject_hashCode_get) + +static bool js_delete_dragonBones_BaseObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BaseObject) + +static bool js_dragonBones_BaseObject_returnToPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseObject *arg1 = (dragonBones::BaseObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->returnToPool(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseObject_returnToPool) + +bool js_register_dragonBones_BaseObject(se::Object* obj) { + auto* cls = se::Class::create("BaseObject", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hashCode", _SE(js_dragonBones_BaseObject_hashCode_get), nullptr); + + cls->defineFunction("returnToPool", _SE(js_dragonBones_BaseObject_returnToPool)); + + + cls->defineStaticFunction("setMaxCount", _SE(js_dragonBones_BaseObject_setMaxCount_static)); + cls->defineStaticFunction("clearPool", _SE(js_dragonBones_BaseObject_clearPool_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BaseObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BaseObject_proto = cls->getProto(); + __jsb_dragonBones_BaseObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_EventObject_class = nullptr; +se::Object* __jsb_dragonBones_EventObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_EventObject) + +static bool js_delete_dragonBones_EventObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_EventObject) + +static bool js_dragonBones_EventObject_time_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->time, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_time_set) + +static bool js_dragonBones_EventObject_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->time, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_time_get) + +static bool js_dragonBones_EventObject_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_type_set) + +static bool js_dragonBones_EventObject_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_type_get) + +static bool js_dragonBones_EventObject_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_name_set) + +static bool js_dragonBones_EventObject_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_name_get) + +static bool js_dragonBones_EventObject_armature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->armature, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_armature_set) + +static bool js_dragonBones_EventObject_armature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->armature, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->armature, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_armature_get) + +static bool js_dragonBones_EventObject_bone_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bone, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_bone_set) + +static bool js_dragonBones_EventObject_bone_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bone, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bone, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_bone_get) + +static bool js_dragonBones_EventObject_slot_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->slot, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_slot_set) + +static bool js_dragonBones_EventObject_slot_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->slot, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->slot, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_slot_get) + +static bool js_dragonBones_EventObject_animationState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->animationState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_EventObject_animationState_set) + +static bool js_dragonBones_EventObject_animationState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->animationState, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->animationState, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_EventObject_animationState_get) + +static bool js_dragonBones_EventObject_getArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::EventObject const *)arg1)->getArmature(); + + 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_dragonBones_EventObject_getArmature) + +static bool js_dragonBones_EventObject_getBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::Bone *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Bone *)((dragonBones::EventObject const *)arg1)->getBone(); + + 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_dragonBones_EventObject_getBone) + +static bool js_dragonBones_EventObject_getSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::Slot *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Slot *)((dragonBones::EventObject const *)arg1)->getSlot(); + + 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_dragonBones_EventObject_getSlot) + +static bool js_dragonBones_EventObject_getAnimationState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::EventObject *arg1 = (dragonBones::EventObject *) NULL ; + dragonBones::AnimationState *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationState *)((dragonBones::EventObject const *)arg1)->getAnimationState(); + + 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_dragonBones_EventObject_getAnimationState) + +bool js_register_dragonBones_EventObject(se::Object* obj) { + auto* cls = se::Class::create("EventObject", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("time", _SE(js_dragonBones_EventObject_time_get), _SE(js_dragonBones_EventObject_time_set)); + cls->defineProperty("type", _SE(js_dragonBones_EventObject_type_get), _SE(js_dragonBones_EventObject_type_set)); + cls->defineProperty("name", _SE(js_dragonBones_EventObject_name_get), _SE(js_dragonBones_EventObject_name_set)); + cls->defineProperty("armature", _SE(js_dragonBones_EventObject_armature_get), _SE(js_dragonBones_EventObject_armature_set)); + cls->defineProperty("bone", _SE(js_dragonBones_EventObject_bone_get), _SE(js_dragonBones_EventObject_bone_set)); + cls->defineProperty("slot", _SE(js_dragonBones_EventObject_slot_get), _SE(js_dragonBones_EventObject_slot_set)); + cls->defineProperty("animationState", _SE(js_dragonBones_EventObject_animationState_get), _SE(js_dragonBones_EventObject_animationState_set)); + + cls->defineFunction("getArmature", _SE(js_dragonBones_EventObject_getArmature)); + cls->defineFunction("getBone", _SE(js_dragonBones_EventObject_getBone)); + cls->defineFunction("getSlot", _SE(js_dragonBones_EventObject_getSlot)); + cls->defineFunction("getAnimationState", _SE(js_dragonBones_EventObject_getAnimationState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_EventObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_EventObject_proto = cls->getProto(); + __jsb_dragonBones_EventObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BaseFactory_class = nullptr; +se::Object* __jsb_dragonBones_BaseFactory_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BaseFactory) + +static bool js_dragonBones_BaseFactory_autoSearch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->autoSearch); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BaseFactory_autoSearch_set) + +static bool js_dragonBones_BaseFactory_autoSearch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->autoSearch, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BaseFactory_autoSearch_get) + +static bool js_delete_dragonBones_BaseFactory(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BaseFactory) + +static bool js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + char *arg2 = (char *) NULL ; + std::string *arg3 = 0 ; + float arg4 ; + ccstd::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesData((char const *)arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + char *arg2 = (char *) NULL ; + std::string *arg3 = 0 ; + ccstd::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesData((char const *)arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + char *arg2 = (char *) NULL ; + ccstd::string temp2 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesData((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; +} + +static bool js_dragonBones_BaseFactory_parseDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_parseDragonBonesData__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_parseDragonBonesData) + +static bool js_dragonBones_BaseFactory_getDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::DragonBonesData *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(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 = (dragonBones::DragonBonesData *)((dragonBones::BaseFactory const *)arg1)->getDragonBonesData((std::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_dragonBones_BaseFactory_getDragonBonesData) + +static bool js_dragonBones_BaseFactory_addDragonBonesData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::DragonBonesData *arg2 = (dragonBones::DragonBonesData *) NULL ; + std::string *arg3 = 0 ; + std::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addDragonBonesData(arg2,(std::string const &)*arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addDragonBonesData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::DragonBonesData *arg2 = (dragonBones::DragonBonesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDragonBonesData(arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_addDragonBonesData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_addDragonBonesData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_addDragonBonesData) + +static bool js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesData((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesData((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeDragonBonesData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_removeDragonBonesData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_removeDragonBonesData) + +static bool js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::TextureAtlasData *arg2 = (dragonBones::TextureAtlasData *) NULL ; + std::string *arg3 = 0 ; + std::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTextureAtlasData(arg2,(std::string const &)*arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::TextureAtlasData *arg2 = (dragonBones::TextureAtlasData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTextureAtlasData(arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_addTextureAtlasData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_addTextureAtlasData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_addTextureAtlasData) + +static bool js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeTextureAtlasData((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeTextureAtlasData((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_removeTextureAtlasData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_removeTextureAtlasData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_removeTextureAtlasData) + +static bool js_dragonBones_BaseFactory_getArmatureData__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::ArmatureData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::ArmatureData *)((dragonBones::BaseFactory const *)arg1)->getArmatureData((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_getArmatureData__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureData *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::ArmatureData *)((dragonBones::BaseFactory const *)arg1)->getArmatureData((std::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; +} + +static bool js_dragonBones_BaseFactory_getArmatureData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_BaseFactory_getArmatureData__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_getArmatureData__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_getArmatureData) + +static bool js_dragonBones_BaseFactory_clear__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->clear(arg2); + + + return true; +} + +static bool js_dragonBones_BaseFactory_clear__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} + +static bool js_dragonBones_BaseFactory_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_dragonBones_BaseFactory_clear__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_BaseFactory_clear__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_clear) + +static bool js_dragonBones_BaseFactory_buildArmature__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_buildArmature__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::string const &)*arg2,(std::string const &)*arg3,(std::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_dragonBones_BaseFactory_buildArmature__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_buildArmature__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::Armature *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::Armature *)((dragonBones::BaseFactory const *)arg1)->buildArmature((std::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; +} + +static bool js_dragonBones_BaseFactory_buildArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_BaseFactory_buildArmature__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_buildArmature) + +static bool js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + dragonBones::Slot *arg6 = (dragonBones::Slot *) NULL ; + int arg7 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceSlotDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6,arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + dragonBones::Slot *arg6 = (dragonBones::Slot *) NULL ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceSlotDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceSlotDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_dragonBones_BaseFactory_replaceSlotDisplay__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_replaceSlotDisplay) + +static bool js_dragonBones_BaseFactory_replaceSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::SkinData *arg3 = (dragonBones::SkinData *) NULL ; + bool arg4 ; + std::vector< std::string > *arg5 = 0 ; + std::vector< std::string > temp5 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceSkin(arg2,arg3,arg4,(std::vector< std::string > const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_replaceSkin) + +static bool js_dragonBones_BaseFactory_replaceAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::ArmatureData *arg3 = (dragonBones::ArmatureData *) NULL ; + bool arg4 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::BaseFactory const *)arg1)->replaceAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::ArmatureData *arg3 = (dragonBones::ArmatureData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(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 = (bool)((dragonBones::BaseFactory const *)arg1)->replaceAnimation(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_dragonBones_BaseFactory_replaceAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_BaseFactory_replaceAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_BaseFactory_replaceAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_replaceAnimation) + +static bool js_dragonBones_BaseFactory_getClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::WorldClock *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::WorldClock *)((dragonBones::BaseFactory const *)arg1)->getClock(); + + 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_dragonBones_BaseFactory_getClock) + +static bool js_dragonBones_BaseFactory_changeSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BaseFactory *arg1 = (dragonBones::BaseFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + dragonBones::SkinData *arg3 = (dragonBones::SkinData *) NULL ; + std::vector< std::string > *arg4 = 0 ; + std::vector< std::string > temp4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((dragonBones::BaseFactory const *)arg1)->changeSkin(arg2,arg3,(std::vector< std::string > const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BaseFactory_changeSkin) + +bool js_register_dragonBones_BaseFactory(se::Object* obj) { + auto* cls = se::Class::create("BaseFactory", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("autoSearch", _SE(js_dragonBones_BaseFactory_autoSearch_get), _SE(js_dragonBones_BaseFactory_autoSearch_set)); + + cls->defineFunction("parseDragonBonesData", _SE(js_dragonBones_BaseFactory_parseDragonBonesData)); + cls->defineFunction("getDragonBonesData", _SE(js_dragonBones_BaseFactory_getDragonBonesData)); + cls->defineFunction("addDragonBonesData", _SE(js_dragonBones_BaseFactory_addDragonBonesData)); + cls->defineFunction("removeDragonBonesData", _SE(js_dragonBones_BaseFactory_removeDragonBonesData)); + cls->defineFunction("addTextureAtlasData", _SE(js_dragonBones_BaseFactory_addTextureAtlasData)); + cls->defineFunction("removeTextureAtlasData", _SE(js_dragonBones_BaseFactory_removeTextureAtlasData)); + cls->defineFunction("getArmatureData", _SE(js_dragonBones_BaseFactory_getArmatureData)); + cls->defineFunction("clear", _SE(js_dragonBones_BaseFactory_clear)); + cls->defineFunction("buildArmature", _SE(js_dragonBones_BaseFactory_buildArmature)); + cls->defineFunction("replaceSlotDisplay", _SE(js_dragonBones_BaseFactory_replaceSlotDisplay)); + cls->defineFunction("replaceSkin", _SE(js_dragonBones_BaseFactory_replaceSkin)); + cls->defineFunction("replaceAnimation", _SE(js_dragonBones_BaseFactory_replaceAnimation)); + cls->defineFunction("getClock", _SE(js_dragonBones_BaseFactory_getClock)); + cls->defineFunction("changeSkin", _SE(js_dragonBones_BaseFactory_changeSkin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BaseFactory)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BaseFactory_proto = cls->getProto(); + __jsb_dragonBones_BaseFactory_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BuildArmaturePackage_class = nullptr; +se::Object* __jsb_dragonBones_BuildArmaturePackage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BuildArmaturePackage) + +static bool js_dragonBones_BuildArmaturePackage_dataName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dataName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_dataName_set) + +static bool js_dragonBones_BuildArmaturePackage_dataName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dataName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dataName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_dataName_get) + +static bool js_dragonBones_BuildArmaturePackage_textureAtlasName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textureAtlasName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_textureAtlasName_set) + +static bool js_dragonBones_BuildArmaturePackage_textureAtlasName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textureAtlasName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textureAtlasName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_textureAtlasName_get) + +static bool js_dragonBones_BuildArmaturePackage_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_data_set) + +static bool js_dragonBones_BuildArmaturePackage_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_data_get) + +static bool js_dragonBones_BuildArmaturePackage_armature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->armature, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_armature_set) + +static bool js_dragonBones_BuildArmaturePackage_armature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->armature, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->armature, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_armature_get) + +static bool js_dragonBones_BuildArmaturePackage_skin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->skin, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BuildArmaturePackage_skin_set) + +static bool js_dragonBones_BuildArmaturePackage_skin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BuildArmaturePackage *arg1 = (dragonBones::BuildArmaturePackage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->skin, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->skin, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BuildArmaturePackage_skin_get) + +static bool js_new_dragonBones_BuildArmaturePackage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::BuildArmaturePackage *result; + result = (dragonBones::BuildArmaturePackage *)new dragonBones::BuildArmaturePackage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_BuildArmaturePackage, __jsb_dragonBones_BuildArmaturePackage_class, js_delete_dragonBones_BuildArmaturePackage) + +static bool js_delete_dragonBones_BuildArmaturePackage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BuildArmaturePackage) + +bool js_register_dragonBones_BuildArmaturePackage(se::Object* obj) { + auto* cls = se::Class::create("BuildArmaturePackage", obj, nullptr, _SE(js_new_dragonBones_BuildArmaturePackage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dataName", _SE(js_dragonBones_BuildArmaturePackage_dataName_get), _SE(js_dragonBones_BuildArmaturePackage_dataName_set)); + cls->defineProperty("textureAtlasName", _SE(js_dragonBones_BuildArmaturePackage_textureAtlasName_get), _SE(js_dragonBones_BuildArmaturePackage_textureAtlasName_set)); + cls->defineProperty("data", _SE(js_dragonBones_BuildArmaturePackage_data_get), _SE(js_dragonBones_BuildArmaturePackage_data_set)); + cls->defineProperty("armature", _SE(js_dragonBones_BuildArmaturePackage_armature_get), _SE(js_dragonBones_BuildArmaturePackage_armature_set)); + cls->defineProperty("skin", _SE(js_dragonBones_BuildArmaturePackage_skin_get), _SE(js_dragonBones_BuildArmaturePackage_skin_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BuildArmaturePackage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BuildArmaturePackage_proto = cls->getProto(); + __jsb_dragonBones_BuildArmaturePackage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_DragonBonesData_class = nullptr; +se::Object* __jsb_dragonBones_DragonBonesData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_DragonBonesData) + +static bool js_dragonBones_DragonBonesData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_DragonBonesData_name_set) + +static bool js_dragonBones_DragonBonesData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_DragonBonesData_name_get) + +static bool js_delete_dragonBones_DragonBonesData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_DragonBonesData) + +static bool js_dragonBones_DragonBonesData_addArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + dragonBones::ArmatureData *arg2 = (dragonBones::ArmatureData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArmature(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_DragonBonesData_addArmature) + +static bool js_dragonBones_DragonBonesData_getArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureData *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(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 = (dragonBones::ArmatureData *)((dragonBones::DragonBonesData const *)arg1)->getArmature((std::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_dragonBones_DragonBonesData_getArmature) + +static bool js_dragonBones_DragonBonesData_getFrameIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + std::vector< unsigned int > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< unsigned int > *)(arg1)->getFrameIndices(); + + 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_dragonBones_DragonBonesData_getFrameIndices) + +static bool js_dragonBones_DragonBonesData_getArmatureNames(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::DragonBonesData *arg1 = (dragonBones::DragonBonesData *) NULL ; + std::vector< std::string > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< std::string > *) &((dragonBones::DragonBonesData const *)arg1)->getArmatureNames(); + + 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_dragonBones_DragonBonesData_getArmatureNames) + +bool js_register_dragonBones_DragonBonesData(se::Object* obj) { + auto* cls = se::Class::create("DragonBonesData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_dragonBones_DragonBonesData_name_get), _SE(js_dragonBones_DragonBonesData_name_set)); + + cls->defineFunction("addArmature", _SE(js_dragonBones_DragonBonesData_addArmature)); + cls->defineFunction("getArmature", _SE(js_dragonBones_DragonBonesData_getArmature)); + cls->defineFunction("getFrameIndices", _SE(js_dragonBones_DragonBonesData_getFrameIndices)); + cls->defineFunction("getArmatureNames", _SE(js_dragonBones_DragonBonesData_getArmatureNames)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_DragonBonesData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_DragonBonesData_proto = cls->getProto(); + __jsb_dragonBones_DragonBonesData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TextureAtlasData_class = nullptr; +se::Object* __jsb_dragonBones_TextureAtlasData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TextureAtlasData) + +static bool js_delete_dragonBones_TextureAtlasData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TextureAtlasData) + +static bool js_dragonBones_TextureAtlasData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TextureAtlasData_name_set) + +static bool js_dragonBones_TextureAtlasData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TextureAtlasData_name_get) + +static bool js_dragonBones_TextureAtlasData_createTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + dragonBones::TextureData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::TextureData *)((dragonBones::TextureAtlasData const *)arg1)->createTexture(); + + 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_dragonBones_TextureAtlasData_createTexture) + +static bool js_dragonBones_TextureAtlasData_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + dragonBones::TextureData *arg2 = (dragonBones::TextureData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TextureAtlasData_addTexture) + +static bool js_dragonBones_TextureAtlasData_getTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureAtlasData *arg1 = (dragonBones::TextureAtlasData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::TextureData *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(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 = (dragonBones::TextureData *)((dragonBones::TextureAtlasData const *)arg1)->getTexture((std::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_dragonBones_TextureAtlasData_getTexture) + +bool js_register_dragonBones_TextureAtlasData(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlasData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_dragonBones_TextureAtlasData_name_get), _SE(js_dragonBones_TextureAtlasData_name_set)); + + cls->defineFunction("createTexture", _SE(js_dragonBones_TextureAtlasData_createTexture)); + cls->defineFunction("addTexture", _SE(js_dragonBones_TextureAtlasData_addTexture)); + cls->defineFunction("getTexture", _SE(js_dragonBones_TextureAtlasData_getTexture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TextureAtlasData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TextureAtlasData_proto = cls->getProto(); + __jsb_dragonBones_TextureAtlasData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TextureData_class = nullptr; +se::Object* __jsb_dragonBones_TextureData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TextureData) + +static bool js_dragonBones_TextureData_createRectangle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Rectangle *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::Rectangle *)dragonBones::TextureData::createRectangle(); + + 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_dragonBones_TextureData_createRectangle_static) + +static bool js_delete_dragonBones_TextureData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TextureData) + +static bool js_dragonBones_TextureData_getRegion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::Rectangle *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Rectangle *)(arg1)->getRegion(); + + 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_dragonBones_TextureData_getRegion) + +static bool js_dragonBones_TextureData_getFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::Rectangle *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Rectangle *)((dragonBones::TextureData const *)arg1)->getFrame(); + + 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_dragonBones_TextureData_getFrame) + +static bool js_dragonBones_TextureData_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::Rectangle *arg2 = (dragonBones::Rectangle *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TextureData_setFrame) + +static bool js_dragonBones_TextureData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::TextureAtlasData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::TextureAtlasData *)((dragonBones::TextureData const *)arg1)->getParent(); + + 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_dragonBones_TextureData_getParent) + +static bool js_dragonBones_TextureData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TextureData *arg1 = (dragonBones::TextureData *) NULL ; + dragonBones::TextureAtlasData *arg2 = (dragonBones::TextureAtlasData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TextureData_setParent) + +bool js_register_dragonBones_TextureData(se::Object* obj) { + auto* cls = se::Class::create("TextureData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getRegion", _SE(js_dragonBones_TextureData_getRegion)); + cls->defineFunction("getFrame", _SE(js_dragonBones_TextureData_getFrame)); + cls->defineFunction("setFrame", _SE(js_dragonBones_TextureData_setFrame)); + cls->defineFunction("getParent", _SE(js_dragonBones_TextureData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_TextureData_setParent)); + + + cls->defineStaticFunction("createRectangle", _SE(js_dragonBones_TextureData_createRectangle_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TextureData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TextureData_proto = cls->getProto(); + __jsb_dragonBones_TextureData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_ArmatureData_class = nullptr; +se::Object* __jsb_dragonBones_ArmatureData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_ArmatureData) + +static bool js_dragonBones_ArmatureData_frameRate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frameRate, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_ArmatureData_frameRate_set) + +static bool js_dragonBones_ArmatureData_frameRate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frameRate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_ArmatureData_frameRate_get) + +static bool js_dragonBones_ArmatureData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_ArmatureData_name_set) + +static bool js_dragonBones_ArmatureData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_ArmatureData_name_get) + +static bool js_delete_dragonBones_ArmatureData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_ArmatureData) + +static bool js_dragonBones_ArmatureData_sortBones(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->sortBones(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_sortBones) + +static bool js_dragonBones_ArmatureData_getBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::BoneData *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(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 = (dragonBones::BoneData *)((dragonBones::ArmatureData const *)arg1)->getBone((std::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_dragonBones_ArmatureData_getBone) + +static bool js_dragonBones_ArmatureData_getSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::SlotData *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(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 = (dragonBones::SlotData *)((dragonBones::ArmatureData const *)arg1)->getSlot((std::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_dragonBones_ArmatureData_getSlot) + +static bool js_dragonBones_ArmatureData_getSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::SkinData *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(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 = (dragonBones::SkinData *)((dragonBones::ArmatureData const *)arg1)->getSkin((std::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_dragonBones_ArmatureData_getSkin) + +static bool js_dragonBones_ArmatureData_getMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::MeshDisplayData *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::MeshDisplayData *)((dragonBones::ArmatureData const *)arg1)->getMesh((std::string const &)*arg2,(std::string const &)*arg3,(std::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; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_getMesh) + +static bool js_dragonBones_ArmatureData_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationData *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(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 = (dragonBones::AnimationData *)((dragonBones::ArmatureData const *)arg1)->getAnimation((std::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_dragonBones_ArmatureData_getAnimation) + +static bool js_dragonBones_ArmatureData_getType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::ArmatureData const *)arg1)->getType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_getType) + +static bool js_dragonBones_ArmatureData_setType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setType(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setType) + +static bool js_dragonBones_ArmatureData_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::Rectangle *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Rectangle *)(arg1)->getAABB(); + + 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_dragonBones_ArmatureData_getAABB) + +static bool js_dragonBones_ArmatureData_getAnimationNames(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + std::vector< std::string > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< std::string > *) &((dragonBones::ArmatureData const *)arg1)->getAnimationNames(); + + 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_dragonBones_ArmatureData_getAnimationNames) + +static bool js_dragonBones_ArmatureData_getDefaultSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::SkinData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::SkinData *)((dragonBones::ArmatureData const *)arg1)->getDefaultSkin(); + + 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_dragonBones_ArmatureData_getDefaultSkin) + +static bool js_dragonBones_ArmatureData_setDefaultSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::SkinData *arg2 = (dragonBones::SkinData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDefaultSkin(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setDefaultSkin) + +static bool js_dragonBones_ArmatureData_getDefaultAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::AnimationData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationData *)((dragonBones::ArmatureData const *)arg1)->getDefaultAnimation(); + + 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_dragonBones_ArmatureData_getDefaultAnimation) + +static bool js_dragonBones_ArmatureData_setDefaultAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::AnimationData *arg2 = (dragonBones::AnimationData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDefaultAnimation(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setDefaultAnimation) + +static bool js_dragonBones_ArmatureData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::DragonBonesData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::DragonBonesData *)((dragonBones::ArmatureData const *)arg1)->getParent(); + + 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_dragonBones_ArmatureData_getParent) + +static bool js_dragonBones_ArmatureData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureData *arg1 = (dragonBones::ArmatureData *) NULL ; + dragonBones::DragonBonesData *arg2 = (dragonBones::DragonBonesData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureData_setParent) + +bool js_register_dragonBones_ArmatureData(se::Object* obj) { + auto* cls = se::Class::create("ArmatureData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frameRate", _SE(js_dragonBones_ArmatureData_frameRate_get), _SE(js_dragonBones_ArmatureData_frameRate_set)); + cls->defineProperty("name", _SE(js_dragonBones_ArmatureData_name_get), _SE(js_dragonBones_ArmatureData_name_set)); + + cls->defineFunction("sortBones", _SE(js_dragonBones_ArmatureData_sortBones)); + cls->defineFunction("getBone", _SE(js_dragonBones_ArmatureData_getBone)); + cls->defineFunction("getSlot", _SE(js_dragonBones_ArmatureData_getSlot)); + cls->defineFunction("getSkin", _SE(js_dragonBones_ArmatureData_getSkin)); + cls->defineFunction("getMesh", _SE(js_dragonBones_ArmatureData_getMesh)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_ArmatureData_getAnimation)); + cls->defineFunction("getType", _SE(js_dragonBones_ArmatureData_getType)); + cls->defineFunction("setType", _SE(js_dragonBones_ArmatureData_setType)); + cls->defineFunction("getAABB", _SE(js_dragonBones_ArmatureData_getAABB)); + cls->defineFunction("getAnimationNames", _SE(js_dragonBones_ArmatureData_getAnimationNames)); + cls->defineFunction("getDefaultSkin", _SE(js_dragonBones_ArmatureData_getDefaultSkin)); + cls->defineFunction("setDefaultSkin", _SE(js_dragonBones_ArmatureData_setDefaultSkin)); + cls->defineFunction("getDefaultAnimation", _SE(js_dragonBones_ArmatureData_getDefaultAnimation)); + cls->defineFunction("setDefaultAnimation", _SE(js_dragonBones_ArmatureData_setDefaultAnimation)); + cls->defineFunction("getParent", _SE(js_dragonBones_ArmatureData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_ArmatureData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_ArmatureData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_ArmatureData_proto = cls->getProto(); + __jsb_dragonBones_ArmatureData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BoneData_class = nullptr; +se::Object* __jsb_dragonBones_BoneData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BoneData) + +static bool js_dragonBones_BoneData_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->length, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BoneData_length_set) + +static bool js_dragonBones_BoneData_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->length, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BoneData_length_get) + +static bool js_dragonBones_BoneData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BoneData_name_set) + +static bool js_dragonBones_BoneData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BoneData_name_get) + +static bool js_dragonBones_BoneData_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BoneData_parent_set) + +static bool js_dragonBones_BoneData_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BoneData_parent_get) + +static bool js_delete_dragonBones_BoneData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BoneData) + +static bool js_dragonBones_BoneData_getTransfrom(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)(arg1)->getTransfrom(); + + 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_dragonBones_BoneData_getTransfrom) + +static bool js_dragonBones_BoneData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + dragonBones::BoneData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoneData *)((dragonBones::BoneData const *)arg1)->getParent(); + + 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_dragonBones_BoneData_getParent) + +static bool js_dragonBones_BoneData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BoneData *arg1 = (dragonBones::BoneData *) NULL ; + dragonBones::BoneData *arg2 = (dragonBones::BoneData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BoneData_setParent) + +bool js_register_dragonBones_BoneData(se::Object* obj) { + auto* cls = se::Class::create("BoneData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("length", _SE(js_dragonBones_BoneData_length_get), _SE(js_dragonBones_BoneData_length_set)); + cls->defineProperty("name", _SE(js_dragonBones_BoneData_name_get), _SE(js_dragonBones_BoneData_name_set)); + cls->defineProperty("parent", _SE(js_dragonBones_BoneData_parent_get), _SE(js_dragonBones_BoneData_parent_set)); + + cls->defineFunction("getTransfrom", _SE(js_dragonBones_BoneData_getTransfrom)); + cls->defineFunction("getParent", _SE(js_dragonBones_BoneData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_BoneData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BoneData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BoneData_proto = cls->getProto(); + __jsb_dragonBones_BoneData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_SlotData_class = nullptr; +se::Object* __jsb_dragonBones_SlotData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_SlotData) + +static bool js_dragonBones_SlotData_blendMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_blendMode_set) + +static bool js_dragonBones_SlotData_blendMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_blendMode_get) + +static bool js_dragonBones_SlotData_displayIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displayIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_displayIndex_set) + +static bool js_dragonBones_SlotData_displayIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displayIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_displayIndex_get) + +static bool js_dragonBones_SlotData_zOrder_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->zOrder, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_zOrder_set) + +static bool js_dragonBones_SlotData_zOrder_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->zOrder, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_zOrder_get) + +static bool js_dragonBones_SlotData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_name_set) + +static bool js_dragonBones_SlotData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_name_get) + +static bool js_dragonBones_SlotData_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SlotData_parent_set) + +static bool js_dragonBones_SlotData_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SlotData_parent_get) + +static bool js_delete_dragonBones_SlotData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_SlotData) + +static bool js_dragonBones_SlotData_getBlendMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::SlotData const *)arg1)->getBlendMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_SlotData_getBlendMode) + +static bool js_dragonBones_SlotData_setBlendMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBlendMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_SlotData_setBlendMode) + +static bool js_dragonBones_SlotData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + dragonBones::BoneData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoneData *)((dragonBones::SlotData const *)arg1)->getParent(); + + 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_dragonBones_SlotData_getParent) + +static bool js_dragonBones_SlotData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SlotData *arg1 = (dragonBones::SlotData *) NULL ; + dragonBones::BoneData *arg2 = (dragonBones::BoneData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_SlotData_setParent) + +bool js_register_dragonBones_SlotData(se::Object* obj) { + auto* cls = se::Class::create("SlotData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("blendMode", _SE(js_dragonBones_SlotData_blendMode_get), _SE(js_dragonBones_SlotData_blendMode_set)); + cls->defineProperty("displayIndex", _SE(js_dragonBones_SlotData_displayIndex_get), _SE(js_dragonBones_SlotData_displayIndex_set)); + cls->defineProperty("zOrder", _SE(js_dragonBones_SlotData_zOrder_get), _SE(js_dragonBones_SlotData_zOrder_set)); + cls->defineProperty("name", _SE(js_dragonBones_SlotData_name_get), _SE(js_dragonBones_SlotData_name_set)); + cls->defineProperty("parent", _SE(js_dragonBones_SlotData_parent_get), _SE(js_dragonBones_SlotData_parent_set)); + + cls->defineFunction("getBlendMode", _SE(js_dragonBones_SlotData_getBlendMode)); + cls->defineFunction("setBlendMode", _SE(js_dragonBones_SlotData_setBlendMode)); + cls->defineFunction("getParent", _SE(js_dragonBones_SlotData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_SlotData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_SlotData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_SlotData_proto = cls->getProto(); + __jsb_dragonBones_SlotData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_SkinData_class = nullptr; +se::Object* __jsb_dragonBones_SkinData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_SkinData) + +static bool js_delete_dragonBones_SkinData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_SkinData) + +static bool js_dragonBones_SkinData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::SkinData *arg1 = (dragonBones::SkinData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_SkinData_name_set) + +static bool js_dragonBones_SkinData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::SkinData *arg1 = (dragonBones::SkinData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_SkinData_name_get) + +bool js_register_dragonBones_SkinData(se::Object* obj) { + auto* cls = se::Class::create("SkinData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_dragonBones_SkinData_name_get), _SE(js_dragonBones_SkinData_name_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_SkinData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_SkinData_proto = cls->getProto(); + __jsb_dragonBones_SkinData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_AnimationData_class = nullptr; +se::Object* __jsb_dragonBones_AnimationData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_AnimationData) + +static bool js_dragonBones_AnimationData_frameCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frameCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_frameCount_set) + +static bool js_dragonBones_AnimationData_frameCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frameCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_frameCount_get) + +static bool js_dragonBones_AnimationData_playTimes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->playTimes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_playTimes_set) + +static bool js_dragonBones_AnimationData_playTimes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->playTimes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_playTimes_get) + +static bool js_dragonBones_AnimationData_duration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->duration, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_duration_set) + +static bool js_dragonBones_AnimationData_duration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->duration, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_duration_get) + +static bool js_dragonBones_AnimationData_fadeInTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fadeInTime, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_fadeInTime_set) + +static bool js_dragonBones_AnimationData_fadeInTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fadeInTime, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_fadeInTime_get) + +static bool js_dragonBones_AnimationData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationData_name_set) + +static bool js_dragonBones_AnimationData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationData_name_get) + +static bool js_delete_dragonBones_AnimationData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_AnimationData) + +static bool js_dragonBones_AnimationData_getBoneCachedFrameIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + std::vector< int > *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(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 = (std::vector< int > *)(arg1)->getBoneCachedFrameIndices((std::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_dragonBones_AnimationData_getBoneCachedFrameIndices) + +static bool js_dragonBones_AnimationData_getSlotCachedFrameIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + std::vector< int > *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(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 = (std::vector< int > *)(arg1)->getSlotCachedFrameIndices((std::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_dragonBones_AnimationData_getSlotCachedFrameIndices) + +static bool js_dragonBones_AnimationData_getZOrderTimeline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + dragonBones::TimelineData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::TimelineData *)((dragonBones::AnimationData const *)arg1)->getZOrderTimeline(); + + 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_dragonBones_AnimationData_getZOrderTimeline) + +static bool js_dragonBones_AnimationData_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + dragonBones::ArmatureData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::ArmatureData *)((dragonBones::AnimationData const *)arg1)->getParent(); + + 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_dragonBones_AnimationData_getParent) + +static bool js_dragonBones_AnimationData_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationData *arg1 = (dragonBones::AnimationData *) NULL ; + dragonBones::ArmatureData *arg2 = (dragonBones::ArmatureData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationData_setParent) + +bool js_register_dragonBones_AnimationData(se::Object* obj) { + auto* cls = se::Class::create("AnimationData", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frameCount", _SE(js_dragonBones_AnimationData_frameCount_get), _SE(js_dragonBones_AnimationData_frameCount_set)); + cls->defineProperty("playTimes", _SE(js_dragonBones_AnimationData_playTimes_get), _SE(js_dragonBones_AnimationData_playTimes_set)); + cls->defineProperty("duration", _SE(js_dragonBones_AnimationData_duration_get), _SE(js_dragonBones_AnimationData_duration_set)); + cls->defineProperty("fadeInTime", _SE(js_dragonBones_AnimationData_fadeInTime_get), _SE(js_dragonBones_AnimationData_fadeInTime_set)); + cls->defineProperty("name", _SE(js_dragonBones_AnimationData_name_get), _SE(js_dragonBones_AnimationData_name_set)); + + cls->defineFunction("getBoneCachedFrameIndices", _SE(js_dragonBones_AnimationData_getBoneCachedFrameIndices)); + cls->defineFunction("getSlotCachedFrameIndices", _SE(js_dragonBones_AnimationData_getSlotCachedFrameIndices)); + cls->defineFunction("getZOrderTimeline", _SE(js_dragonBones_AnimationData_getZOrderTimeline)); + cls->defineFunction("getParent", _SE(js_dragonBones_AnimationData_getParent)); + cls->defineFunction("setParent", _SE(js_dragonBones_AnimationData_setParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_AnimationData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_AnimationData_proto = cls->getProto(); + __jsb_dragonBones_AnimationData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TimelineData_class = nullptr; +se::Object* __jsb_dragonBones_TimelineData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TimelineData) + +static bool js_dragonBones_TimelineData_getTypeIndex_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = dragonBones::TimelineData::getTypeIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TimelineData_getTypeIndex_static) + +static bool js_new_dragonBones_TimelineData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::TimelineData *result; + result = (dragonBones::TimelineData *)new dragonBones::TimelineData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_TimelineData, __jsb_dragonBones_TimelineData_class, js_delete_dragonBones_TimelineData) + +static bool js_delete_dragonBones_TimelineData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TimelineData) + +static bool js_dragonBones_TimelineData_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TimelineData_type_set) + +static bool js_dragonBones_TimelineData_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TimelineData_type_get) + +static bool js_dragonBones_TimelineData_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TimelineData_offset_set) + +static bool js_dragonBones_TimelineData_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TimelineData_offset_get) + +static bool js_dragonBones_TimelineData_frameIndicesOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->frameIndicesOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TimelineData_frameIndicesOffset_set) + +static bool js_dragonBones_TimelineData_frameIndicesOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->frameIndicesOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TimelineData_frameIndicesOffset_get) + +static bool js_dragonBones_TimelineData_getType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::TimelineData const *)arg1)->getType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TimelineData_getType) + +static bool js_dragonBones_TimelineData_setType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TimelineData *arg1 = (dragonBones::TimelineData *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setType(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TimelineData_setType) + +bool js_register_dragonBones_TimelineData(se::Object* obj) { + auto* cls = se::Class::create("TimelineData", obj, __jsb_dragonBones_BaseObject_proto, _SE(js_new_dragonBones_TimelineData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_dragonBones_TimelineData_type_get), _SE(js_dragonBones_TimelineData_type_set)); + cls->defineProperty("offset", _SE(js_dragonBones_TimelineData_offset_get), _SE(js_dragonBones_TimelineData_offset_set)); + cls->defineProperty("frameIndicesOffset", _SE(js_dragonBones_TimelineData_frameIndicesOffset_get), _SE(js_dragonBones_TimelineData_frameIndicesOffset_set)); + + cls->defineFunction("getType", _SE(js_dragonBones_TimelineData_getType)); + cls->defineFunction("setType", _SE(js_dragonBones_TimelineData_setType)); + + + cls->defineStaticFunction("getTypeIndex", _SE(js_dragonBones_TimelineData_getTypeIndex_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TimelineData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TimelineData_proto = cls->getProto(); + __jsb_dragonBones_TimelineData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_WorldClock_class = nullptr; +se::Object* __jsb_dragonBones_WorldClock_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_WorldClock) + +static bool js_dragonBones_WorldClock_time_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->time, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_WorldClock_time_set) + +static bool js_dragonBones_WorldClock_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->time, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_WorldClock_time_get) + +static bool js_dragonBones_WorldClock_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_WorldClock_timeScale_set) + +static bool js_dragonBones_WorldClock_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_WorldClock_timeScale_get) + +static bool js_delete_dragonBones_WorldClock(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_WorldClock) + +static bool js_dragonBones_WorldClock_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->advanceTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_advanceTime) + +static bool js_dragonBones_WorldClock_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->render(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_render) + +static bool js_dragonBones_WorldClock_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_clear) + +static bool js_dragonBones_WorldClock_getClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + dragonBones::WorldClock *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::WorldClock *)((dragonBones::WorldClock const *)arg1)->getClock(); + + 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_dragonBones_WorldClock_getClock) + +static bool js_dragonBones_WorldClock_setClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *arg1 = (dragonBones::WorldClock *) NULL ; + dragonBones::WorldClock *arg2 = (dragonBones::WorldClock *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setClock(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_WorldClock_setClock) + +static bool js_dragonBones_WorldClock_getStaticClock_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::WorldClock *)dragonBones::WorldClock::getStaticClock(); + + 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_dragonBones_WorldClock_getStaticClock_static) + +bool js_register_dragonBones_WorldClock(se::Object* obj) { + auto* cls = se::Class::create("WorldClock", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("time", _SE(js_dragonBones_WorldClock_time_get), _SE(js_dragonBones_WorldClock_time_set)); + cls->defineProperty("timeScale", _SE(js_dragonBones_WorldClock_timeScale_get), _SE(js_dragonBones_WorldClock_timeScale_set)); + + cls->defineFunction("advanceTime", _SE(js_dragonBones_WorldClock_advanceTime)); + cls->defineFunction("render", _SE(js_dragonBones_WorldClock_render)); + cls->defineFunction("clear", _SE(js_dragonBones_WorldClock_clear)); + cls->defineFunction("getClock", _SE(js_dragonBones_WorldClock_getClock)); + cls->defineFunction("setClock", _SE(js_dragonBones_WorldClock_setClock)); + + + cls->defineStaticFunction("getStaticClock", _SE(js_dragonBones_WorldClock_getStaticClock_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_WorldClock)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_WorldClock_proto = cls->getProto(); + __jsb_dragonBones_WorldClock_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Animation_class = nullptr; +se::Object* __jsb_dragonBones_Animation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Animation) + +static bool js_dragonBones_Animation_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Animation_timeScale_set) + +static bool js_dragonBones_Animation_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Animation_timeScale_get) + +static bool js_delete_dragonBones_Animation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Animation) + +static bool js_dragonBones_Animation_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->init(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_init) + +static bool js_dragonBones_Animation_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->advanceTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_advanceTime) + +static bool js_dragonBones_Animation_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_reset) + +static bool js_dragonBones_Animation_stop__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->stop((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_Animation_stop__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stop(); + + + return true; +} + +static bool js_dragonBones_Animation_stop(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_dragonBones_Animation_stop__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_Animation_stop__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_stop) + +static bool js_dragonBones_Animation_play__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->play((std::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; +} + +static bool js_dragonBones_Animation_play__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->play((std::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; +} + +static bool js_dragonBones_Animation_play__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationState *)(arg1)->play(); + + 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_dragonBones_Animation_play(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_play__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_play__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_Animation_play__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_play) + +static bool js_dragonBones_Animation_fadeIn__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + int arg5 ; + std::string *arg6 = 0 ; + dragonBones::AnimationFadeOutMode arg7 ; + std::string temp2 ; + std::string temp6 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6,arg7); + + 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_dragonBones_Animation_fadeIn__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + int arg5 ; + std::string *arg6 = 0 ; + std::string temp2 ; + std::string temp6 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + int arg5 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->fadeIn((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->fadeIn((std::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; +} + +static bool js_dragonBones_Animation_fadeIn__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->fadeIn((std::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; +} + +static bool js_dragonBones_Animation_fadeIn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_dragonBones_Animation_fadeIn__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_dragonBones_Animation_fadeIn__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_dragonBones_Animation_fadeIn__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_dragonBones_Animation_fadeIn__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_fadeIn__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_fadeIn__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_fadeIn) + +static bool js_dragonBones_Animation_gotoAndPlayByTime__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByTime((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_gotoAndPlayByTime__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByTime__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_Animation_gotoAndPlayByTime__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndPlayByTime__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndPlayByTime__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndPlayByTime) + +static bool js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + unsigned int arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByFrame((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + unsigned int arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndPlayByFrame__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndPlayByFrame) + +static bool js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + int arg4 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByProgress((std::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndPlayByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndPlayByProgress(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndPlayByProgress__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndPlayByProgress) + +static bool js_dragonBones_Animation_gotoAndStopByTime__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByTime__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByTime((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndStopByTime__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndStopByTime__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndStopByTime) + +static bool js_dragonBones_Animation_gotoAndStopByFrame__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + unsigned int arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByFrame__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByFrame((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndStopByFrame__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndStopByFrame__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndStopByFrame) + +static bool js_dragonBones_Animation_gotoAndStopByProgress__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByProgress__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::AnimationState *)(arg1)->gotoAndStopByProgress((std::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; +} + +static bool js_dragonBones_Animation_gotoAndStopByProgress(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Animation_gotoAndStopByProgress__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Animation_gotoAndStopByProgress__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Animation_gotoAndStopByProgress) + +static bool js_dragonBones_Animation_getState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::AnimationState *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(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 = (dragonBones::AnimationState *)((dragonBones::Animation const *)arg1)->getState((std::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_dragonBones_Animation_getState) + +static bool js_dragonBones_Animation_hasAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *arg2 = 0 ; + std::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(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)((dragonBones::Animation const *)arg1)->hasAnimation((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_hasAnimation) + +static bool js_dragonBones_Animation_isPlaying(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Animation const *)arg1)->isPlaying(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_isPlaying) + +static bool js_dragonBones_Animation_isCompleted(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Animation const *)arg1)->isCompleted(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Animation_isCompleted) + +static bool js_dragonBones_Animation_getLastAnimationName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Animation const *)arg1)->getLastAnimationName(); + + 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_dragonBones_Animation_getLastAnimationName) + +static bool js_dragonBones_Animation_getAnimationNames(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + std::vector< std::string > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< std::string > *) &((dragonBones::Animation const *)arg1)->getAnimationNames(); + + 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_dragonBones_Animation_getAnimationNames) + +static bool js_dragonBones_Animation_getLastAnimationState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Animation *arg1 = (dragonBones::Animation *) NULL ; + dragonBones::AnimationState *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationState *)((dragonBones::Animation const *)arg1)->getLastAnimationState(); + + 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_dragonBones_Animation_getLastAnimationState) + +bool js_register_dragonBones_Animation(se::Object* obj) { + auto* cls = se::Class::create("Animation", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("timeScale", _SE(js_dragonBones_Animation_timeScale_get), _SE(js_dragonBones_Animation_timeScale_set)); + + cls->defineFunction("init", _SE(js_dragonBones_Animation_init)); + cls->defineFunction("advanceTime", _SE(js_dragonBones_Animation_advanceTime)); + cls->defineFunction("reset", _SE(js_dragonBones_Animation_reset)); + cls->defineFunction("stop", _SE(js_dragonBones_Animation_stop)); + cls->defineFunction("play", _SE(js_dragonBones_Animation_play)); + cls->defineFunction("fadeIn", _SE(js_dragonBones_Animation_fadeIn)); + cls->defineFunction("gotoAndPlayByTime", _SE(js_dragonBones_Animation_gotoAndPlayByTime)); + cls->defineFunction("gotoAndPlayByFrame", _SE(js_dragonBones_Animation_gotoAndPlayByFrame)); + cls->defineFunction("gotoAndPlayByProgress", _SE(js_dragonBones_Animation_gotoAndPlayByProgress)); + cls->defineFunction("gotoAndStopByTime", _SE(js_dragonBones_Animation_gotoAndStopByTime)); + cls->defineFunction("gotoAndStopByFrame", _SE(js_dragonBones_Animation_gotoAndStopByFrame)); + cls->defineFunction("gotoAndStopByProgress", _SE(js_dragonBones_Animation_gotoAndStopByProgress)); + cls->defineFunction("getState", _SE(js_dragonBones_Animation_getState)); + cls->defineFunction("hasAnimation", _SE(js_dragonBones_Animation_hasAnimation)); + cls->defineFunction("isPlaying", _SE(js_dragonBones_Animation_isPlaying)); + cls->defineFunction("isCompleted", _SE(js_dragonBones_Animation_isCompleted)); + cls->defineFunction("getLastAnimationName", _SE(js_dragonBones_Animation_getLastAnimationName)); + cls->defineFunction("getAnimationNames", _SE(js_dragonBones_Animation_getAnimationNames)); + cls->defineFunction("getLastAnimationState", _SE(js_dragonBones_Animation_getLastAnimationState)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Animation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Animation_proto = cls->getProto(); + __jsb_dragonBones_Animation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_AnimationState_class = nullptr; +se::Object* __jsb_dragonBones_AnimationState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_AnimationState) + +static bool js_dragonBones_AnimationState_actionEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->actionEnabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_actionEnabled_set) + +static bool js_dragonBones_AnimationState_actionEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->actionEnabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_actionEnabled_get) + +static bool js_dragonBones_AnimationState_additiveBlending_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->additiveBlending); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_additiveBlending_set) + +static bool js_dragonBones_AnimationState_additiveBlending_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->additiveBlending, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_additiveBlending_get) + +static bool js_dragonBones_AnimationState_displayControl_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displayControl); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_displayControl_set) + +static bool js_dragonBones_AnimationState_displayControl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displayControl, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_displayControl_get) + +static bool js_dragonBones_AnimationState_resetToPose_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->resetToPose); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_resetToPose_set) + +static bool js_dragonBones_AnimationState_resetToPose_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->resetToPose, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_resetToPose_get) + +static bool js_dragonBones_AnimationState_playTimes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->playTimes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_playTimes_set) + +static bool js_dragonBones_AnimationState_playTimes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->playTimes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_playTimes_get) + +static bool js_dragonBones_AnimationState_layer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_layer_set) + +static bool js_dragonBones_AnimationState_layer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_layer_get) + +static bool js_dragonBones_AnimationState_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_timeScale_set) + +static bool js_dragonBones_AnimationState_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_timeScale_get) + +static bool js_dragonBones_AnimationState_weight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->weight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_weight_set) + +static bool js_dragonBones_AnimationState_weight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->weight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_weight_get) + +static bool js_dragonBones_AnimationState_autoFadeOutTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->autoFadeOutTime, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_autoFadeOutTime_set) + +static bool js_dragonBones_AnimationState_autoFadeOutTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->autoFadeOutTime, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_autoFadeOutTime_get) + +static bool js_dragonBones_AnimationState_fadeTotalTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->fadeTotalTime, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_fadeTotalTime_set) + +static bool js_dragonBones_AnimationState_fadeTotalTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->fadeTotalTime, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_fadeTotalTime_get) + +static bool js_dragonBones_AnimationState_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_name_set) + +static bool js_dragonBones_AnimationState_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_name_get) + +static bool js_dragonBones_AnimationState_group_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->group, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState_group_set) + +static bool js_dragonBones_AnimationState_group_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->group, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->group, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState_group_get) + +static bool js_dragonBones_AnimationState__playheadState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_playheadState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__playheadState_set) + +static bool js_dragonBones_AnimationState__playheadState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_playheadState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__playheadState_get) + +static bool js_dragonBones_AnimationState__fadeState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fadeState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__fadeState_set) + +static bool js_dragonBones_AnimationState__fadeState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fadeState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__fadeState_get) + +static bool js_dragonBones_AnimationState__subFadeState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_subFadeState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__subFadeState_set) + +static bool js_dragonBones_AnimationState__subFadeState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_subFadeState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__subFadeState_get) + +static bool js_dragonBones_AnimationState__position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__position_set) + +static bool js_dragonBones_AnimationState__position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_position, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__position_get) + +static bool js_dragonBones_AnimationState__duration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_duration, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__duration_set) + +static bool js_dragonBones_AnimationState__duration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_duration, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__duration_get) + +static bool js_dragonBones_AnimationState__fadeProgress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fadeProgress, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__fadeProgress_set) + +static bool js_dragonBones_AnimationState__fadeProgress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fadeProgress, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__fadeProgress_get) + +static bool js_dragonBones_AnimationState__weightResult_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_weightResult, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__weightResult_set) + +static bool js_dragonBones_AnimationState__weightResult_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_weightResult, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__weightResult_get) + +static bool js_dragonBones_AnimationState__animationData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_animationData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_AnimationState__animationData_set) + +static bool js_dragonBones_AnimationState__animationData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_animationData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_animationData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_AnimationState__animationData_get) + +static bool js_delete_dragonBones_AnimationState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_AnimationState) + +static bool js_dragonBones_AnimationState_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->advanceTime(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_advanceTime) + +static bool js_dragonBones_AnimationState_play(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->play(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_play) + +static bool js_dragonBones_AnimationState_stop(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stop(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_stop) + +static bool js_dragonBones_AnimationState_fadeOut__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + bool arg3 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->fadeOut(arg2,arg3); + + + return true; +} + +static bool js_dragonBones_AnimationState_fadeOut__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->fadeOut(arg2); + + + return true; +} + +static bool js_dragonBones_AnimationState_fadeOut(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_AnimationState_fadeOut__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_AnimationState_fadeOut__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_fadeOut) + +static bool js_dragonBones_AnimationState_containsBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + std::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(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)((dragonBones::AnimationState const *)arg1)->containsBoneMask((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_containsBoneMask) + +static bool js_dragonBones_AnimationState_addBoneMask__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addBoneMask((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_AnimationState_addBoneMask__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addBoneMask((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_AnimationState_addBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_AnimationState_addBoneMask__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_AnimationState_addBoneMask__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_addBoneMask) + +static bool js_dragonBones_AnimationState_removeBoneMask__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeBoneMask((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_AnimationState_removeBoneMask__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeBoneMask((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_AnimationState_removeBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_AnimationState_removeBoneMask__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_AnimationState_removeBoneMask__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_removeBoneMask) + +static bool js_dragonBones_AnimationState_removeAllBoneMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeAllBoneMask(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_removeAllBoneMask) + +static bool js_dragonBones_AnimationState_isFadeIn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isFadeIn(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isFadeIn) + +static bool js_dragonBones_AnimationState_isFadeOut(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isFadeOut(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isFadeOut) + +static bool js_dragonBones_AnimationState_isFadeComplete(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isFadeComplete(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isFadeComplete) + +static bool js_dragonBones_AnimationState_isPlaying(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isPlaying(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isPlaying) + +static bool js_dragonBones_AnimationState_isCompleted(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::AnimationState const *)arg1)->isCompleted(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_isCompleted) + +static bool js_dragonBones_AnimationState_getCurrentPlayTimes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + unsigned int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (unsigned int)((dragonBones::AnimationState const *)arg1)->getCurrentPlayTimes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_getCurrentPlayTimes) + +static bool js_dragonBones_AnimationState_getTotalTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((dragonBones::AnimationState const *)arg1)->getTotalTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_getTotalTime) + +static bool js_dragonBones_AnimationState_getCurrentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((dragonBones::AnimationState const *)arg1)->getCurrentTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_getCurrentTime) + +static bool js_dragonBones_AnimationState_setCurrentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCurrentTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_AnimationState_setCurrentTime) + +static bool js_dragonBones_AnimationState_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::AnimationState const *)arg1)->getName(); + + 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_dragonBones_AnimationState_getName) + +static bool js_dragonBones_AnimationState_getAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::AnimationState *arg1 = (dragonBones::AnimationState *) NULL ; + dragonBones::AnimationData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::AnimationData *)((dragonBones::AnimationState const *)arg1)->getAnimationData(); + + 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_dragonBones_AnimationState_getAnimationData) + +bool js_register_dragonBones_AnimationState(se::Object* obj) { + auto* cls = se::Class::create("AnimationState", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("actionEnabled", _SE(js_dragonBones_AnimationState_actionEnabled_get), _SE(js_dragonBones_AnimationState_actionEnabled_set)); + cls->defineProperty("additiveBlending", _SE(js_dragonBones_AnimationState_additiveBlending_get), _SE(js_dragonBones_AnimationState_additiveBlending_set)); + cls->defineProperty("displayControl", _SE(js_dragonBones_AnimationState_displayControl_get), _SE(js_dragonBones_AnimationState_displayControl_set)); + cls->defineProperty("resetToPose", _SE(js_dragonBones_AnimationState_resetToPose_get), _SE(js_dragonBones_AnimationState_resetToPose_set)); + cls->defineProperty("playTimes", _SE(js_dragonBones_AnimationState_playTimes_get), _SE(js_dragonBones_AnimationState_playTimes_set)); + cls->defineProperty("layer", _SE(js_dragonBones_AnimationState_layer_get), _SE(js_dragonBones_AnimationState_layer_set)); + cls->defineProperty("timeScale", _SE(js_dragonBones_AnimationState_timeScale_get), _SE(js_dragonBones_AnimationState_timeScale_set)); + cls->defineProperty("weight", _SE(js_dragonBones_AnimationState_weight_get), _SE(js_dragonBones_AnimationState_weight_set)); + cls->defineProperty("autoFadeOutTime", _SE(js_dragonBones_AnimationState_autoFadeOutTime_get), _SE(js_dragonBones_AnimationState_autoFadeOutTime_set)); + cls->defineProperty("fadeTotalTime", _SE(js_dragonBones_AnimationState_fadeTotalTime_get), _SE(js_dragonBones_AnimationState_fadeTotalTime_set)); + cls->defineProperty("name", _SE(js_dragonBones_AnimationState_name_get), _SE(js_dragonBones_AnimationState_name_set)); + cls->defineProperty("group", _SE(js_dragonBones_AnimationState_group_get), _SE(js_dragonBones_AnimationState_group_set)); + cls->defineProperty("_playheadState", _SE(js_dragonBones_AnimationState__playheadState_get), _SE(js_dragonBones_AnimationState__playheadState_set)); + cls->defineProperty("_fadeState", _SE(js_dragonBones_AnimationState__fadeState_get), _SE(js_dragonBones_AnimationState__fadeState_set)); + cls->defineProperty("_subFadeState", _SE(js_dragonBones_AnimationState__subFadeState_get), _SE(js_dragonBones_AnimationState__subFadeState_set)); + cls->defineProperty("_position", _SE(js_dragonBones_AnimationState__position_get), _SE(js_dragonBones_AnimationState__position_set)); + cls->defineProperty("_duration", _SE(js_dragonBones_AnimationState__duration_get), _SE(js_dragonBones_AnimationState__duration_set)); + cls->defineProperty("_fadeProgress", _SE(js_dragonBones_AnimationState__fadeProgress_get), _SE(js_dragonBones_AnimationState__fadeProgress_set)); + cls->defineProperty("_weightResult", _SE(js_dragonBones_AnimationState__weightResult_get), _SE(js_dragonBones_AnimationState__weightResult_set)); + cls->defineProperty("_animationData", _SE(js_dragonBones_AnimationState__animationData_get), _SE(js_dragonBones_AnimationState__animationData_set)); + + cls->defineFunction("advanceTime", _SE(js_dragonBones_AnimationState_advanceTime)); + cls->defineFunction("play", _SE(js_dragonBones_AnimationState_play)); + cls->defineFunction("stop", _SE(js_dragonBones_AnimationState_stop)); + cls->defineFunction("fadeOut", _SE(js_dragonBones_AnimationState_fadeOut)); + cls->defineFunction("containsBoneMask", _SE(js_dragonBones_AnimationState_containsBoneMask)); + cls->defineFunction("addBoneMask", _SE(js_dragonBones_AnimationState_addBoneMask)); + cls->defineFunction("removeBoneMask", _SE(js_dragonBones_AnimationState_removeBoneMask)); + cls->defineFunction("removeAllBoneMask", _SE(js_dragonBones_AnimationState_removeAllBoneMask)); + cls->defineFunction("isFadeIn", _SE(js_dragonBones_AnimationState_isFadeIn)); + cls->defineFunction("isFadeOut", _SE(js_dragonBones_AnimationState_isFadeOut)); + cls->defineFunction("isFadeComplete", _SE(js_dragonBones_AnimationState_isFadeComplete)); + cls->defineFunction("isPlaying", _SE(js_dragonBones_AnimationState_isPlaying)); + cls->defineFunction("isCompleted", _SE(js_dragonBones_AnimationState_isCompleted)); + cls->defineFunction("getCurrentPlayTimes", _SE(js_dragonBones_AnimationState_getCurrentPlayTimes)); + cls->defineFunction("getTotalTime", _SE(js_dragonBones_AnimationState_getTotalTime)); + cls->defineFunction("getCurrentTime", _SE(js_dragonBones_AnimationState_getCurrentTime)); + cls->defineFunction("setCurrentTime", _SE(js_dragonBones_AnimationState_setCurrentTime)); + cls->defineFunction("getName", _SE(js_dragonBones_AnimationState_getName)); + cls->defineFunction("getAnimationData", _SE(js_dragonBones_AnimationState_getAnimationData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_AnimationState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_AnimationState_proto = cls->getProto(); + __jsb_dragonBones_AnimationState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BonePose_class = nullptr; +se::Object* __jsb_dragonBones_BonePose_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BonePose) + +static bool js_dragonBones_BonePose_getTypeIndex_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = dragonBones::BonePose::getTypeIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BonePose_getTypeIndex_static) + +static bool js_new_dragonBones_BonePose(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::BonePose *result; + result = (dragonBones::BonePose *)new dragonBones::BonePose(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_BonePose, __jsb_dragonBones_BonePose_class, js_delete_dragonBones_BonePose) + +static bool js_delete_dragonBones_BonePose(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BonePose) + +static bool js_dragonBones_BonePose_current_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->current, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BonePose_current_set) + +static bool js_dragonBones_BonePose_current_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->current, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->current, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BonePose_current_get) + +static bool js_dragonBones_BonePose_delta_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->delta, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BonePose_delta_set) + +static bool js_dragonBones_BonePose_delta_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->delta, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->delta, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BonePose_delta_get) + +static bool js_dragonBones_BonePose_result_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->result, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BonePose_result_set) + +static bool js_dragonBones_BonePose_result_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BonePose *arg1 = (dragonBones::BonePose *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BonePose_result_get) + +bool js_register_dragonBones_BonePose(se::Object* obj) { + auto* cls = se::Class::create("BonePose", obj, __jsb_dragonBones_BaseObject_proto, _SE(js_new_dragonBones_BonePose)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("current", _SE(js_dragonBones_BonePose_current_get), _SE(js_dragonBones_BonePose_current_set)); + cls->defineProperty("delta", _SE(js_dragonBones_BonePose_delta_get), _SE(js_dragonBones_BonePose_delta_set)); + cls->defineProperty("result", _SE(js_dragonBones_BonePose_result_get), _SE(js_dragonBones_BonePose_result_set)); + + + + cls->defineStaticFunction("getTypeIndex", _SE(js_dragonBones_BonePose_getTypeIndex_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BonePose)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BonePose_proto = cls->getProto(); + __jsb_dragonBones_BonePose_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_BlendState_class = nullptr; +se::Object* __jsb_dragonBones_BlendState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_BlendState) + +static bool js_dragonBones_BlendState_dirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_dirty_set) + +static bool js_dragonBones_BlendState_dirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_dirty_get) + +static bool js_dragonBones_BlendState_layer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_layer_set) + +static bool js_dragonBones_BlendState_layer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_layer_get) + +static bool js_dragonBones_BlendState_leftWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->leftWeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_leftWeight_set) + +static bool js_dragonBones_BlendState_leftWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->leftWeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_leftWeight_get) + +static bool js_dragonBones_BlendState_layerWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerWeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_layerWeight_set) + +static bool js_dragonBones_BlendState_layerWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerWeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_layerWeight_get) + +static bool js_dragonBones_BlendState_blendWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendWeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_BlendState_blendWeight_set) + +static bool js_dragonBones_BlendState_blendWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendWeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_BlendState_blendWeight_get) + +static bool js_dragonBones_BlendState_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + float arg2 ; + int arg3 ; + int result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->update(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BlendState_update) + +static bool js_dragonBones_BlendState_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::BlendState *arg1 = (dragonBones::BlendState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_BlendState_clear) + +static bool js_new_dragonBones_BlendState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::BlendState *result; + result = (dragonBones::BlendState *)new dragonBones::BlendState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_BlendState, __jsb_dragonBones_BlendState_class, js_delete_dragonBones_BlendState) + +static bool js_delete_dragonBones_BlendState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_BlendState) + +bool js_register_dragonBones_BlendState(se::Object* obj) { + auto* cls = se::Class::create("BlendState", obj, nullptr, _SE(js_new_dragonBones_BlendState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dirty", _SE(js_dragonBones_BlendState_dirty_get), _SE(js_dragonBones_BlendState_dirty_set)); + cls->defineProperty("layer", _SE(js_dragonBones_BlendState_layer_get), _SE(js_dragonBones_BlendState_layer_set)); + cls->defineProperty("leftWeight", _SE(js_dragonBones_BlendState_leftWeight_get), _SE(js_dragonBones_BlendState_leftWeight_set)); + cls->defineProperty("layerWeight", _SE(js_dragonBones_BlendState_layerWeight_get), _SE(js_dragonBones_BlendState_layerWeight_set)); + cls->defineProperty("blendWeight", _SE(js_dragonBones_BlendState_blendWeight_get), _SE(js_dragonBones_BlendState_blendWeight_set)); + + cls->defineFunction("update", _SE(js_dragonBones_BlendState_update)); + cls->defineFunction("clear", _SE(js_dragonBones_BlendState_clear)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_BlendState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_BlendState_proto = cls->getProto(); + __jsb_dragonBones_BlendState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_TransformObject_class = nullptr; +se::Object* __jsb_dragonBones_TransformObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_TransformObject) + +static bool js_delete_dragonBones_TransformObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_TransformObject) + +static bool js_dragonBones_TransformObject_globalTransformMatrix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->globalTransformMatrix, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_globalTransformMatrix_set) + +static bool js_dragonBones_TransformObject_globalTransformMatrix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->globalTransformMatrix, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->globalTransformMatrix, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_globalTransformMatrix_get) + +static bool js_dragonBones_TransformObject_global_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->global, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_global_set) + +static bool js_dragonBones_TransformObject_global_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->global, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->global, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_global_get) + +static bool js_dragonBones_TransformObject_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_offset_set) + +static bool js_dragonBones_TransformObject_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->offset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_offset_get) + +static bool js_dragonBones_TransformObject_origin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->origin, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_origin_set) + +static bool js_dragonBones_TransformObject_origin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->origin, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->origin, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_origin_get) + +static bool js_dragonBones_TransformObject_userData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->userData); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject_userData_set) + +static bool js_dragonBones_TransformObject_userData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->userData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->userData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject_userData_get) + +static bool js_dragonBones_TransformObject__armature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_armature, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_TransformObject__armature_set) + +static bool js_dragonBones_TransformObject__armature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_armature, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_armature, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_TransformObject__armature_get) + +static bool js_dragonBones_TransformObject_updateGlobalTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateGlobalTransform(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_TransformObject_updateGlobalTransform) + +static bool js_dragonBones_TransformObject_getArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::TransformObject const *)arg1)->getArmature(); + + 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_dragonBones_TransformObject_getArmature) + +static bool js_dragonBones_TransformObject_getGlobalTransformMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Matrix *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Matrix *)(arg1)->getGlobalTransformMatrix(); + + 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_dragonBones_TransformObject_getGlobalTransformMatrix) + +static bool js_dragonBones_TransformObject_getGlobal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)(arg1)->getGlobal(); + + 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_dragonBones_TransformObject_getGlobal) + +static bool js_dragonBones_TransformObject_getOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)(arg1)->getOffset(); + + 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_dragonBones_TransformObject_getOffset) + +static bool js_dragonBones_TransformObject_getOrigin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::TransformObject *arg1 = (dragonBones::TransformObject *) NULL ; + dragonBones::Transform *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Transform *)((dragonBones::TransformObject const *)arg1)->getOrigin(); + + 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_dragonBones_TransformObject_getOrigin) + +bool js_register_dragonBones_TransformObject(se::Object* obj) { + auto* cls = se::Class::create("TransformObject", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("globalTransformMatrix", _SE(js_dragonBones_TransformObject_globalTransformMatrix_get), _SE(js_dragonBones_TransformObject_globalTransformMatrix_set)); + cls->defineProperty("global", _SE(js_dragonBones_TransformObject_global_get), _SE(js_dragonBones_TransformObject_global_set)); + cls->defineProperty("offset", _SE(js_dragonBones_TransformObject_offset_get), _SE(js_dragonBones_TransformObject_offset_set)); + cls->defineProperty("origin", _SE(js_dragonBones_TransformObject_origin_get), _SE(js_dragonBones_TransformObject_origin_set)); + cls->defineProperty("userData", _SE(js_dragonBones_TransformObject_userData_get), _SE(js_dragonBones_TransformObject_userData_set)); + cls->defineProperty("_armature", _SE(js_dragonBones_TransformObject__armature_get), _SE(js_dragonBones_TransformObject__armature_set)); + + cls->defineFunction("updateGlobalTransform", _SE(js_dragonBones_TransformObject_updateGlobalTransform)); + cls->defineFunction("getArmature", _SE(js_dragonBones_TransformObject_getArmature)); + cls->defineFunction("getGlobalTransformMatrix", _SE(js_dragonBones_TransformObject_getGlobalTransformMatrix)); + cls->defineFunction("getGlobal", _SE(js_dragonBones_TransformObject_getGlobal)); + cls->defineFunction("getOffset", _SE(js_dragonBones_TransformObject_getOffset)); + cls->defineFunction("getOrigin", _SE(js_dragonBones_TransformObject_getOrigin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_TransformObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_TransformObject_proto = cls->getProto(); + __jsb_dragonBones_TransformObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Slot_class = nullptr; +se::Object* __jsb_dragonBones_Slot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Slot) + +static bool js_dragonBones_Slot_displayController_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->displayController, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Slot_displayController_set) + +static bool js_dragonBones_Slot_displayController_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->displayController, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->displayController, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Slot_displayController_get) + +static bool js_dragonBones_Slot__zOrder_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_zOrder, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Slot__zOrder_set) + +static bool js_dragonBones_Slot__zOrder_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_zOrder, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Slot__zOrder_get) + +static bool js_delete_dragonBones_Slot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Slot) + +static bool js_dragonBones_Slot__updateColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->_updateColor(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot__updateColor) + +static bool js_dragonBones_Slot__setZorder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->_setZorder(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot__setZorder) + +static bool js_dragonBones_Slot_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_update) + +static bool js_dragonBones_Slot_updateTransformAndMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateTransformAndMatrix(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_updateTransformAndMatrix) + +static bool js_dragonBones_Slot_containsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + float arg2 ; + float arg3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->containsPoint(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_containsPoint) + +static bool js_dragonBones_Slot_invalidUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidUpdate(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_invalidUpdate) + +static bool js_dragonBones_Slot_getVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Slot const *)arg1)->getVisible(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_getVisible) + +static bool js_dragonBones_Slot_setVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setVisible(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_setVisible) + +static bool js_dragonBones_Slot_getDisplayIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::Slot const *)arg1)->getDisplayIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_getDisplayIndex) + +static bool js_dragonBones_Slot_setDisplayIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDisplayIndex(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_setDisplayIndex) + +static bool js_dragonBones_Slot_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Slot const *)arg1)->getName(); + + 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_dragonBones_Slot_getName) + +static bool js_dragonBones_Slot_getRawDisplayDatas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + std::vector< dragonBones::DisplayData * > *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(s); + if (nullptr == arg1) return true; + result = (std::vector< dragonBones::DisplayData * > *)((dragonBones::Slot const *)arg1)->getRawDisplayDatas(); + + 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_dragonBones_Slot_getRawDisplayDatas) + +static bool js_dragonBones_Slot_getSlotData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::SlotData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::SlotData *)((dragonBones::Slot const *)arg1)->getSlotData(); + + 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_dragonBones_Slot_getSlotData) + +static bool js_dragonBones_Slot_getBoundingBoxData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::BoundingBoxData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoundingBoxData *)((dragonBones::Slot const *)arg1)->getBoundingBoxData(); + + 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_dragonBones_Slot_getBoundingBoxData) + +static bool js_dragonBones_Slot_getChildArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::Slot const *)arg1)->getChildArmature(); + + 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_dragonBones_Slot_getChildArmature) + +static bool js_dragonBones_Slot_setChildArmature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setChildArmature(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Slot_setChildArmature) + +static bool js_dragonBones_Slot_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Slot *arg1 = (dragonBones::Slot *) NULL ; + dragonBones::Bone *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Bone *)((dragonBones::Slot const *)arg1)->getParent(); + + 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_dragonBones_Slot_getParent) + +bool js_register_dragonBones_Slot(se::Object* obj) { + auto* cls = se::Class::create("Slot", obj, __jsb_dragonBones_TransformObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("displayController", _SE(js_dragonBones_Slot_displayController_get), _SE(js_dragonBones_Slot_displayController_set)); + cls->defineProperty("_zOrder", _SE(js_dragonBones_Slot__zOrder_get), _SE(js_dragonBones_Slot__zOrder_set)); + + cls->defineFunction("_updateColor", _SE(js_dragonBones_Slot__updateColor)); + cls->defineFunction("_setZorder", _SE(js_dragonBones_Slot__setZorder)); + cls->defineFunction("update", _SE(js_dragonBones_Slot_update)); + cls->defineFunction("updateTransformAndMatrix", _SE(js_dragonBones_Slot_updateTransformAndMatrix)); + cls->defineFunction("containsPoint", _SE(js_dragonBones_Slot_containsPoint)); + cls->defineFunction("invalidUpdate", _SE(js_dragonBones_Slot_invalidUpdate)); + cls->defineFunction("getVisible", _SE(js_dragonBones_Slot_getVisible)); + cls->defineFunction("setVisible", _SE(js_dragonBones_Slot_setVisible)); + cls->defineFunction("getDisplayIndex", _SE(js_dragonBones_Slot_getDisplayIndex)); + cls->defineFunction("setDisplayIndex", _SE(js_dragonBones_Slot_setDisplayIndex)); + cls->defineFunction("getName", _SE(js_dragonBones_Slot_getName)); + cls->defineFunction("getRawDisplayDatas", _SE(js_dragonBones_Slot_getRawDisplayDatas)); + cls->defineFunction("getSlotData", _SE(js_dragonBones_Slot_getSlotData)); + cls->defineFunction("getBoundingBoxData", _SE(js_dragonBones_Slot_getBoundingBoxData)); + cls->defineFunction("getChildArmature", _SE(js_dragonBones_Slot_getChildArmature)); + cls->defineFunction("setChildArmature", _SE(js_dragonBones_Slot_setChildArmature)); + cls->defineFunction("getParent", _SE(js_dragonBones_Slot_getParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Slot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Slot_proto = cls->getProto(); + __jsb_dragonBones_Slot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Bone_class = nullptr; +se::Object* __jsb_dragonBones_Bone_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Bone) + +static bool js_delete_dragonBones_Bone(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Bone) + +static bool js_dragonBones_Bone_offsetMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offsetMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone_offsetMode_set) + +static bool js_dragonBones_Bone_offsetMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offsetMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->offsetMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone_offsetMode_get) + +static bool js_dragonBones_Bone_animationPose_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->animationPose, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone_animationPose_set) + +static bool js_dragonBones_Bone_animationPose_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->animationPose, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->animationPose, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone_animationPose_get) + +static bool js_dragonBones_Bone__transformDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_transformDirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__transformDirty_set) + +static bool js_dragonBones_Bone__transformDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_transformDirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__transformDirty_get) + +static bool js_dragonBones_Bone__childrenTransformDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_childrenTransformDirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__childrenTransformDirty_set) + +static bool js_dragonBones_Bone__childrenTransformDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_childrenTransformDirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__childrenTransformDirty_get) + +static bool js_dragonBones_Bone__hasConstraint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_hasConstraint); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__hasConstraint_set) + +static bool js_dragonBones_Bone__hasConstraint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_hasConstraint, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__hasConstraint_get) + +static bool js_dragonBones_Bone__blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__blendState_set) + +static bool js_dragonBones_Bone__blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__blendState_get) + +static bool js_dragonBones_Bone__boneData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_boneData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Bone__boneData_set) + +static bool js_dragonBones_Bone__boneData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_boneData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_boneData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Bone__boneData_get) + +static bool js_dragonBones_Bone_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::BoneData *arg2 = (dragonBones::BoneData *) NULL ; + dragonBones::Armature *arg3 = (dragonBones::Armature *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->init((dragonBones::BoneData const *)arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_init) + +static bool js_dragonBones_Bone_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_update) + +static bool js_dragonBones_Bone_updateByConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateByConstraint(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_updateByConstraint) + +static bool js_dragonBones_Bone_invalidUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidUpdate(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_invalidUpdate) + +static bool js_dragonBones_Bone_contains(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::Bone *arg2 = (dragonBones::Bone *) 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((dragonBones::Bone const *)arg1)->contains((dragonBones::Bone const *)arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_contains) + +static bool js_dragonBones_Bone_getBoneData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::BoneData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::BoneData *)((dragonBones::Bone const *)arg1)->getBoneData(); + + 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_dragonBones_Bone_getBoneData) + +static bool js_dragonBones_Bone_getVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Bone const *)arg1)->getVisible(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_getVisible) + +static bool js_dragonBones_Bone_setVisible(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setVisible(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_setVisible) + +static bool js_dragonBones_Bone_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Bone const *)arg1)->getName(); + + 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_dragonBones_Bone_getName) + +static bool js_dragonBones_Bone_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + dragonBones::Bone *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Bone *)((dragonBones::Bone const *)arg1)->getParent(); + + 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_dragonBones_Bone_getParent) + +static bool js_dragonBones_Bone_getOffsetMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((dragonBones::Bone const *)arg1)->getOffsetMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_getOffsetMode) + +static bool js_dragonBones_Bone_setOffsetMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Bone *arg1 = (dragonBones::Bone *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOffsetMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Bone_setOffsetMode) + +bool js_register_dragonBones_Bone(se::Object* obj) { + auto* cls = se::Class::create("Bone", obj, __jsb_dragonBones_TransformObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("offsetMode", _SE(js_dragonBones_Bone_offsetMode_get), _SE(js_dragonBones_Bone_offsetMode_set)); + cls->defineProperty("animationPose", _SE(js_dragonBones_Bone_animationPose_get), _SE(js_dragonBones_Bone_animationPose_set)); + cls->defineProperty("_transformDirty", _SE(js_dragonBones_Bone__transformDirty_get), _SE(js_dragonBones_Bone__transformDirty_set)); + cls->defineProperty("_childrenTransformDirty", _SE(js_dragonBones_Bone__childrenTransformDirty_get), _SE(js_dragonBones_Bone__childrenTransformDirty_set)); + cls->defineProperty("_hasConstraint", _SE(js_dragonBones_Bone__hasConstraint_get), _SE(js_dragonBones_Bone__hasConstraint_set)); + cls->defineProperty("_blendState", _SE(js_dragonBones_Bone__blendState_get), _SE(js_dragonBones_Bone__blendState_set)); + cls->defineProperty("_boneData", _SE(js_dragonBones_Bone__boneData_get), _SE(js_dragonBones_Bone__boneData_set)); + + cls->defineFunction("init", _SE(js_dragonBones_Bone_init)); + cls->defineFunction("update", _SE(js_dragonBones_Bone_update)); + cls->defineFunction("updateByConstraint", _SE(js_dragonBones_Bone_updateByConstraint)); + cls->defineFunction("invalidUpdate", _SE(js_dragonBones_Bone_invalidUpdate)); + cls->defineFunction("contains", _SE(js_dragonBones_Bone_contains)); + cls->defineFunction("getBoneData", _SE(js_dragonBones_Bone_getBoneData)); + cls->defineFunction("getVisible", _SE(js_dragonBones_Bone_getVisible)); + cls->defineFunction("setVisible", _SE(js_dragonBones_Bone_setVisible)); + cls->defineFunction("getName", _SE(js_dragonBones_Bone_getName)); + cls->defineFunction("getParent", _SE(js_dragonBones_Bone_getParent)); + cls->defineFunction("getOffsetMode", _SE(js_dragonBones_Bone_getOffsetMode)); + cls->defineFunction("setOffsetMode", _SE(js_dragonBones_Bone_setOffsetMode)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Bone)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Bone_proto = cls->getProto(); + __jsb_dragonBones_Bone_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_Armature_class = nullptr; +se::Object* __jsb_dragonBones_Armature_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_Armature) + +static bool js_dragonBones_Armature_inheritAnimation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inheritAnimation); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature_inheritAnimation_set) + +static bool js_dragonBones_Armature_inheritAnimation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inheritAnimation, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature_inheritAnimation_get) + +static bool js_dragonBones_Armature_userData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->userData); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature_userData_set) + +static bool js_dragonBones_Armature_userData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->userData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->userData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature_userData_get) + +static bool js_dragonBones_Armature__cacheFrameIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_cacheFrameIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__cacheFrameIndex_set) + +static bool js_dragonBones_Armature__cacheFrameIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_cacheFrameIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__cacheFrameIndex_get) + +static bool js_dragonBones_Armature__armatureData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_armatureData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__armatureData_set) + +static bool js_dragonBones_Armature__armatureData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_armatureData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_armatureData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__armatureData_get) + +static bool js_dragonBones_Armature__parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__parent_set) + +static bool js_dragonBones_Armature__parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__parent_get) + +static bool js_dragonBones_Armature__replaceTextureAtlasData_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_replaceTextureAtlasData, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_dragonBones_Armature__replaceTextureAtlasData_set) + +static bool js_dragonBones_Armature__replaceTextureAtlasData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_replaceTextureAtlasData, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_replaceTextureAtlasData, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_dragonBones_Armature__replaceTextureAtlasData_get) + +static bool js_delete_dragonBones_Armature(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_Armature) + +static bool js_dragonBones_Armature__addBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Bone *arg2 = (dragonBones::Bone *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_addBone(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature__addBone) + +static bool js_dragonBones_Armature__addSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Slot *arg2 = (dragonBones::Slot *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_addSlot(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature__addSlot) + +static bool js_dragonBones_Armature__bufferAction(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::EventObject *arg2 = (dragonBones::EventObject *) NULL ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_bufferAction(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature__bufferAction) + +static bool js_dragonBones_Armature_dispose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dispose(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_dispose) + +static bool js_dragonBones_Armature_advanceTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->advanceTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_advanceTime) + +static bool js_dragonBones_Armature_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->render(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_render) + +static bool js_dragonBones_Armature_invalidUpdate__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->invalidUpdate((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_Armature_invalidUpdate__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->invalidUpdate((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_Armature_invalidUpdate__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidUpdate(); + + + return true; +} + +static bool js_dragonBones_Armature_invalidUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_Armature_invalidUpdate__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_Armature_invalidUpdate__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_dragonBones_Armature_invalidUpdate__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_Armature_invalidUpdate) + +static bool js_dragonBones_Armature_containsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + float arg2 ; + float arg3 ; + dragonBones::Slot *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(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 = (dragonBones::Slot *)((dragonBones::Armature const *)arg1)->containsPoint(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_dragonBones_Armature_containsPoint) + +static bool js_dragonBones_Armature_getBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::Bone *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(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 = (dragonBones::Bone *)((dragonBones::Armature const *)arg1)->getBone((std::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_dragonBones_Armature_getBone) + +static bool js_dragonBones_Armature_getSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::Slot *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(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 = (dragonBones::Slot *)((dragonBones::Armature const *)arg1)->getSlot((std::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_dragonBones_Armature_getSlot) + +static bool js_dragonBones_Armature_getFlipX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Armature const *)arg1)->getFlipX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_getFlipX) + +static bool js_dragonBones_Armature_setFlipX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFlipX(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setFlipX) + +static bool js_dragonBones_Armature_getFlipY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((dragonBones::Armature const *)arg1)->getFlipY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_getFlipY) + +static bool js_dragonBones_Armature_setFlipY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFlipY(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setFlipY) + +static bool js_dragonBones_Armature_getCacheFrameRate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + unsigned int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (unsigned int)((dragonBones::Armature const *)arg1)->getCacheFrameRate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_getCacheFrameRate) + +static bool js_dragonBones_Armature_setCacheFrameRate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + unsigned int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCacheFrameRate(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setCacheFrameRate) + +static bool js_dragonBones_Armature_getName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((dragonBones::Armature const *)arg1)->getName(); + + 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_dragonBones_Armature_getName) + +static bool js_dragonBones_Armature_getArmatureData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::ArmatureData *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::ArmatureData *)((dragonBones::Armature const *)arg1)->getArmatureData(); + + 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_dragonBones_Armature_getArmatureData) + +static bool js_dragonBones_Armature_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Animation *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Animation *)((dragonBones::Armature const *)arg1)->getAnimation(); + + 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_dragonBones_Armature_getAnimation) + +static bool js_dragonBones_Armature_getProxy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::IArmatureProxy *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::IArmatureProxy *)((dragonBones::Armature const *)arg1)->getProxy(); + + 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_dragonBones_Armature_getProxy) + +static bool js_dragonBones_Armature_getEventDispatcher(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::IEventDispatcher *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::IEventDispatcher *)((dragonBones::Armature const *)arg1)->getEventDispatcher(); + + 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_dragonBones_Armature_getEventDispatcher) + +static bool js_dragonBones_Armature_getClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::WorldClock *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::WorldClock *)((dragonBones::Armature const *)arg1)->getClock(); + + 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_dragonBones_Armature_getClock) + +static bool js_dragonBones_Armature_setClock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::WorldClock *arg2 = (dragonBones::WorldClock *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setClock(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_Armature_setClock) + +static bool js_dragonBones_Armature_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::Armature *arg1 = (dragonBones::Armature *) NULL ; + dragonBones::Slot *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Slot *)((dragonBones::Armature const *)arg1)->getParent(); + + 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_dragonBones_Armature_getParent) + +bool js_register_dragonBones_Armature(se::Object* obj) { + auto* cls = se::Class::create("Armature", obj, __jsb_dragonBones_BaseObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("inheritAnimation", _SE(js_dragonBones_Armature_inheritAnimation_get), _SE(js_dragonBones_Armature_inheritAnimation_set)); + cls->defineProperty("userData", _SE(js_dragonBones_Armature_userData_get), _SE(js_dragonBones_Armature_userData_set)); + cls->defineProperty("_cacheFrameIndex", _SE(js_dragonBones_Armature__cacheFrameIndex_get), _SE(js_dragonBones_Armature__cacheFrameIndex_set)); + cls->defineProperty("_armatureData", _SE(js_dragonBones_Armature__armatureData_get), _SE(js_dragonBones_Armature__armatureData_set)); + cls->defineProperty("_parent", _SE(js_dragonBones_Armature__parent_get), _SE(js_dragonBones_Armature__parent_set)); + cls->defineProperty("_replaceTextureAtlasData", _SE(js_dragonBones_Armature__replaceTextureAtlasData_get), _SE(js_dragonBones_Armature__replaceTextureAtlasData_set)); + + cls->defineFunction("_addBone", _SE(js_dragonBones_Armature__addBone)); + cls->defineFunction("_addSlot", _SE(js_dragonBones_Armature__addSlot)); + cls->defineFunction("_bufferAction", _SE(js_dragonBones_Armature__bufferAction)); + cls->defineFunction("dispose", _SE(js_dragonBones_Armature_dispose)); + cls->defineFunction("advanceTime", _SE(js_dragonBones_Armature_advanceTime)); + cls->defineFunction("render", _SE(js_dragonBones_Armature_render)); + cls->defineFunction("invalidUpdate", _SE(js_dragonBones_Armature_invalidUpdate)); + cls->defineFunction("containsPoint", _SE(js_dragonBones_Armature_containsPoint)); + cls->defineFunction("getBone", _SE(js_dragonBones_Armature_getBone)); + cls->defineFunction("getSlot", _SE(js_dragonBones_Armature_getSlot)); + cls->defineFunction("getFlipX", _SE(js_dragonBones_Armature_getFlipX)); + cls->defineFunction("setFlipX", _SE(js_dragonBones_Armature_setFlipX)); + cls->defineFunction("getFlipY", _SE(js_dragonBones_Armature_getFlipY)); + cls->defineFunction("setFlipY", _SE(js_dragonBones_Armature_setFlipY)); + cls->defineFunction("getCacheFrameRate", _SE(js_dragonBones_Armature_getCacheFrameRate)); + cls->defineFunction("setCacheFrameRate", _SE(js_dragonBones_Armature_setCacheFrameRate)); + cls->defineFunction("getName", _SE(js_dragonBones_Armature_getName)); + cls->defineFunction("getArmatureData", _SE(js_dragonBones_Armature_getArmatureData)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_Armature_getAnimation)); + cls->defineFunction("getProxy", _SE(js_dragonBones_Armature_getProxy)); + cls->defineFunction("getEventDispatcher", _SE(js_dragonBones_Armature_getEventDispatcher)); + cls->defineFunction("getClock", _SE(js_dragonBones_Armature_getClock)); + cls->defineFunction("setClock", _SE(js_dragonBones_Armature_setClock)); + cls->defineFunction("getParent", _SE(js_dragonBones_Armature_getParent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_Armature)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_Armature_proto = cls->getProto(); + __jsb_dragonBones_Armature_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCArmatureDisplay_class = nullptr; +se::Object* __jsb_dragonBones_CCArmatureDisplay_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureDisplay) + +static bool js_dragonBones_CCArmatureDisplay_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::CCArmatureDisplay *)dragonBones::CCArmatureDisplay::create(); + + 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_dragonBones_CCArmatureDisplay_create_static) + +static bool js_new_dragonBones_CCArmatureDisplay(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::CCArmatureDisplay *result; + result = (dragonBones::CCArmatureDisplay *)new dragonBones::CCArmatureDisplay(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_CCArmatureDisplay, __jsb_dragonBones_CCArmatureDisplay_class, js_delete_dragonBones_CCArmatureDisplay) + +static bool js_delete_dragonBones_CCArmatureDisplay(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureDisplay) + +static bool js_dragonBones_CCArmatureDisplay_dbInit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->dbInit(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbInit) + +static bool js_dragonBones_CCArmatureDisplay_dbClear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dbClear(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbClear) + +static bool js_dragonBones_CCArmatureDisplay_dbUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dbUpdate(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbUpdate) + +static bool js_dragonBones_CCArmatureDisplay_dbRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dbRender(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dbRender) + +static bool js_dragonBones_CCArmatureDisplay_dispose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dispose(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dispose) + +static bool js_dragonBones_CCArmatureDisplay_hasDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + std::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(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)((dragonBones::CCArmatureDisplay const *)arg1)->hasDBEventListener((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_hasDBEventListener) + +static bool js_dragonBones_CCArmatureDisplay_dispatchDBEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + dragonBones::EventObject *arg3 = (dragonBones::EventObject *) NULL ; + std::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(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)->dispatchDBEvent((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_dispatchDBEvent) + +static bool js_dragonBones_CCArmatureDisplay_addDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + std::function< void (dragonBones::EventObject *) > *arg3 = 0 ; + std::string temp2 ; + std::function< void (dragonBones::EventObject *) > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addDBEventListener((std::string const &)*arg2,(std::function< void (dragonBones::EventObject *) > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_addDBEventListener) + +static bool js_dragonBones_CCArmatureDisplay_removeDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + std::string *arg2 = 0 ; + std::function< void (dragonBones::EventObject *) > *arg3 = 0 ; + std::string temp2 ; + std::function< void (dragonBones::EventObject *) > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeDBEventListener((std::string const &)*arg2,(std::function< void (dragonBones::EventObject *) > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_removeDBEventListener) + +static bool js_dragonBones_CCArmatureDisplay_setDBEventCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::CCArmatureDisplay::dbEventCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDBEventCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setDBEventCallback) + +static bool js_dragonBones_CCArmatureDisplay_armature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::CCArmatureDisplay const *)arg1)->getArmature(); + + 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_dragonBones_CCArmatureDisplay_armature) + +static bool js_dragonBones_CCArmatureDisplay_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::Animation *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Animation *)((dragonBones::CCArmatureDisplay const *)arg1)->getAnimation(); + + 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_dragonBones_CCArmatureDisplay_getAnimation) + +static bool js_dragonBones_CCArmatureDisplay_getDebugData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((dragonBones::CCArmatureDisplay const *)arg1)->getDebugData(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_getDebugData) + +static bool js_dragonBones_CCArmatureDisplay_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((dragonBones::CCArmatureDisplay const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_getSharedBufferOffset) + +static bool js_dragonBones_CCArmatureDisplay_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setColor) + +static bool js_dragonBones_CCArmatureDisplay_setDebugBonesEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugBonesEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setDebugBonesEnabled) + +static bool js_dragonBones_CCArmatureDisplay_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setBatchEnabled) + +static bool js_dragonBones_CCArmatureDisplay_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setAttachEnabled) + +static bool js_dragonBones_CCArmatureDisplay_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setOpacityModifyRGB) + +static bool js_dragonBones_CCArmatureDisplay_convertToRootSpace(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + float arg2 ; + float arg3 ; + cc::Vec2 *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(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::Vec2 *) &((dragonBones::CCArmatureDisplay const *)arg1)->convertToRootSpace(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_dragonBones_CCArmatureDisplay_convertToRootSpace) + +static bool js_dragonBones_CCArmatureDisplay_getRootDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + dragonBones::CCArmatureDisplay *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::CCArmatureDisplay *)(arg1)->getRootDisplay(); + + 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_dragonBones_CCArmatureDisplay_getRootDisplay) + +static bool js_dragonBones_CCArmatureDisplay_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setMaterial) + +static bool js_dragonBones_CCArmatureDisplay_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureDisplay *arg1 = (dragonBones::CCArmatureDisplay *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureDisplay_setRenderEntity) + +bool js_register_dragonBones_CCArmatureDisplay(se::Object* obj) { + auto* cls = se::Class::create("CCArmatureDisplay", obj, nullptr, _SE(js_new_dragonBones_CCArmatureDisplay)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("dbInit", _SE(js_dragonBones_CCArmatureDisplay_dbInit)); + cls->defineFunction("dbClear", _SE(js_dragonBones_CCArmatureDisplay_dbClear)); + cls->defineFunction("dbUpdate", _SE(js_dragonBones_CCArmatureDisplay_dbUpdate)); + cls->defineFunction("dbRender", _SE(js_dragonBones_CCArmatureDisplay_dbRender)); + cls->defineFunction("dispose", _SE(js_dragonBones_CCArmatureDisplay_dispose)); + cls->defineFunction("hasDBEventListener", _SE(js_dragonBones_CCArmatureDisplay_hasDBEventListener)); + cls->defineFunction("dispatchDBEvent", _SE(js_dragonBones_CCArmatureDisplay_dispatchDBEvent)); + cls->defineFunction("addDBEventListener", _SE(js_dragonBones_CCArmatureDisplay_addDBEventListener)); + cls->defineFunction("removeDBEventListener", _SE(js_dragonBones_CCArmatureDisplay_removeDBEventListener)); + cls->defineFunction("setDBEventCallback", _SE(js_dragonBones_CCArmatureDisplay_setDBEventCallback)); + cls->defineFunction("armature", _SE(js_dragonBones_CCArmatureDisplay_armature)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_CCArmatureDisplay_getAnimation)); + cls->defineFunction("getDebugData", _SE(js_dragonBones_CCArmatureDisplay_getDebugData)); + cls->defineFunction("getSharedBufferOffset", _SE(js_dragonBones_CCArmatureDisplay_getSharedBufferOffset)); + cls->defineFunction("setColor", _SE(js_dragonBones_CCArmatureDisplay_setColor)); + cls->defineFunction("setDebugBonesEnabled", _SE(js_dragonBones_CCArmatureDisplay_setDebugBonesEnabled)); + cls->defineFunction("setBatchEnabled", _SE(js_dragonBones_CCArmatureDisplay_setBatchEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_dragonBones_CCArmatureDisplay_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_dragonBones_CCArmatureDisplay_setOpacityModifyRGB)); + cls->defineFunction("convertToRootSpace", _SE(js_dragonBones_CCArmatureDisplay_convertToRootSpace)); + cls->defineFunction("getRootDisplay", _SE(js_dragonBones_CCArmatureDisplay_getRootDisplay)); + cls->defineFunction("setMaterial", _SE(js_dragonBones_CCArmatureDisplay_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_dragonBones_CCArmatureDisplay_setRenderEntity)); + + + cls->defineStaticFunction("create", _SE(js_dragonBones_CCArmatureDisplay_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCArmatureDisplay)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCArmatureDisplay_proto = cls->getProto(); + __jsb_dragonBones_CCArmatureDisplay_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCFactory_class = nullptr; +se::Object* __jsb_dragonBones_CCFactory_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCFactory) + +static bool js_dragonBones_CCFactory_isInit_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)dragonBones::CCFactory::isInit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_isInit_static) + +static bool js_dragonBones_CCFactory_getFactory_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::CCFactory *)dragonBones::CCFactory::getFactory(); + + 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_dragonBones_CCFactory_getFactory_static) + +static bool js_dragonBones_CCFactory_destroyFactory_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + dragonBones::CCFactory::destroyFactory(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_destroyFactory_static) + +static bool js_new_dragonBones_CCFactory(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::CCFactory *result; + result = (dragonBones::CCFactory *)new dragonBones::CCFactory(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_CCFactory, __jsb_dragonBones_CCFactory_class, js_delete_dragonBones_CCFactory) + +static bool js_dragonBones_CCFactory_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_update) + +static bool js_dragonBones_CCFactory_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_render) + +static bool js_dragonBones_CCFactory_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_stopSchedule) + +static bool js_delete_dragonBones_CCFactory(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCFactory) + +static bool js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + std::string temp5 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::string const &)*arg2,(std::string const &)*arg3,(std::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_dragonBones_CCFactory_buildArmatureDisplay__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::CCArmatureDisplay *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->buildArmatureDisplay((std::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; +} + +static bool js_dragonBones_CCFactory_buildArmatureDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_CCFactory_buildArmatureDisplay__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_buildArmatureDisplay) + +static bool js_dragonBones_CCFactory_getSoundEventManager(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::CCArmatureDisplay *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::CCArmatureDisplay *)((dragonBones::CCFactory const *)arg1)->getSoundEventManager(); + + 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_dragonBones_CCFactory_getSoundEventManager) + +static bool js_dragonBones_CCFactory_getClock_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::WorldClock *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::WorldClock *)dragonBones::CCFactory::getClock(); + + 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_dragonBones_CCFactory_getClock_static) + +static bool js_dragonBones_CCFactory_add(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->add(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_add) + +static bool js_dragonBones_CCFactory_remove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::Armature *arg2 = (dragonBones::Armature *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->remove(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_remove) + +static bool js_dragonBones_CCFactory_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_setTimeScale) + +static bool js_dragonBones_CCFactory_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_getTimeScale) + +static bool js_dragonBones_CCFactory_getDragonBones(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + dragonBones::DragonBones *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::DragonBones *)(arg1)->getDragonBones(); + + 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_dragonBones_CCFactory_getDragonBones) + +static bool js_dragonBones_CCFactory_getDragonBonesDataByUUID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::DragonBonesData *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(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 = (dragonBones::DragonBonesData *)(arg1)->getDragonBonesDataByUUID((std::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_dragonBones_CCFactory_getDragonBonesDataByUUID) + +static bool js_dragonBones_CCFactory_removeTextureAtlasDataByIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::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(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)->removeTextureAtlasDataByIndex((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_removeTextureAtlasDataByIndex) + +static bool js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesDataByUUID((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->removeDragonBonesDataByUUID((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_CCFactory_removeDragonBonesDataByUUID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_CCFactory_removeDragonBonesDataByUUID__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_removeDragonBonesDataByUUID) + +static bool js_dragonBones_CCFactory_getTextureAtlasDataByIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::string temp2 ; + dragonBones::CCTextureAtlasData *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(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 = (dragonBones::CCTextureAtlasData *)((dragonBones::CCFactory const *)arg1)->getTextureAtlasDataByIndex((std::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_dragonBones_CCFactory_getTextureAtlasDataByIndex) + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + float arg4 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesDataByPath((std::string const &)*arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesDataByPath((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::CCFactory *arg1 = (dragonBones::CCFactory *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::DragonBonesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (dragonBones::DragonBonesData *)(arg1)->parseDragonBonesDataByPath((std::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; +} + +static bool js_dragonBones_CCFactory_parseDragonBonesDataByPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_CCFactory_parseDragonBonesDataByPath__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_CCFactory_parseDragonBonesDataByPath) + +bool js_register_dragonBones_CCFactory(se::Object* obj) { + auto* cls = se::Class::create("CCFactory", obj, __jsb_dragonBones_BaseFactory_proto, _SE(js_new_dragonBones_CCFactory)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_dragonBones_CCFactory_update)); + cls->defineFunction("render", _SE(js_dragonBones_CCFactory_render)); + cls->defineFunction("stopSchedule", _SE(js_dragonBones_CCFactory_stopSchedule)); + cls->defineFunction("buildArmatureDisplay", _SE(js_dragonBones_CCFactory_buildArmatureDisplay)); + cls->defineFunction("getSoundEventManager", _SE(js_dragonBones_CCFactory_getSoundEventManager)); + cls->defineFunction("add", _SE(js_dragonBones_CCFactory_add)); + cls->defineFunction("remove", _SE(js_dragonBones_CCFactory_remove)); + cls->defineFunction("setTimeScale", _SE(js_dragonBones_CCFactory_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_dragonBones_CCFactory_getTimeScale)); + cls->defineFunction("getDragonBones", _SE(js_dragonBones_CCFactory_getDragonBones)); + cls->defineFunction("getDragonBonesDataByUUID", _SE(js_dragonBones_CCFactory_getDragonBonesDataByUUID)); + cls->defineFunction("removeTextureAtlasDataByIndex", _SE(js_dragonBones_CCFactory_removeTextureAtlasDataByIndex)); + cls->defineFunction("removeDragonBonesDataByUUID", _SE(js_dragonBones_CCFactory_removeDragonBonesDataByUUID)); + cls->defineFunction("getTextureAtlasDataByIndex", _SE(js_dragonBones_CCFactory_getTextureAtlasDataByIndex)); + cls->defineFunction("parseDragonBonesDataByPath", _SE(js_dragonBones_CCFactory_parseDragonBonesDataByPath)); + + + cls->defineStaticFunction("isInit", _SE(js_dragonBones_CCFactory_isInit_static)); + cls->defineStaticFunction("getFactory", _SE(js_dragonBones_CCFactory_getFactory_static)); + cls->defineStaticFunction("destroyFactory", _SE(js_dragonBones_CCFactory_destroyFactory_static)); + cls->defineStaticFunction("getClock", _SE(js_dragonBones_CCFactory_getClock_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCFactory)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCFactory_proto = cls->getProto(); + __jsb_dragonBones_CCFactory_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCSlot_class = nullptr; +se::Object* __jsb_dragonBones_CCSlot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCSlot) + +static bool js_delete_dragonBones_CCSlot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCSlot) + +static bool js_dragonBones_CCSlot_updateWorldMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCSlot *arg1 = (dragonBones::CCSlot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldMatrix(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCSlot_updateWorldMatrix) + +bool js_register_dragonBones_CCSlot(se::Object* obj) { + auto* cls = se::Class::create("CCSlot", obj, __jsb_dragonBones_Slot_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateWorldMatrix", _SE(js_dragonBones_CCSlot_updateWorldMatrix)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCSlot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCSlot_proto = cls->getProto(); + __jsb_dragonBones_CCSlot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_CCArmatureCacheDisplay_class = nullptr; +se::Object* __jsb_dragonBones_CCArmatureCacheDisplay_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureCacheDisplay) + +static bool js_new_dragonBones_CCArmatureCacheDisplay(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + bool arg4 ; + std::string temp1 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::CCArmatureCacheDisplay *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[3], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (dragonBones::CCArmatureCacheDisplay *)new dragonBones::CCArmatureCacheDisplay((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_CCArmatureCacheDisplay, __jsb_dragonBones_CCArmatureCacheDisplay_class, js_delete_dragonBones_CCArmatureCacheDisplay) + +static bool js_delete_dragonBones_CCArmatureCacheDisplay(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_CCArmatureCacheDisplay) + +static bool js_dragonBones_CCArmatureCacheDisplay_dispose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dispose(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_dispose) + +static bool js_dragonBones_CCArmatureCacheDisplay_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_update) + +static bool js_dragonBones_CCArmatureCacheDisplay_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_render) + +static bool js_dragonBones_CCArmatureCacheDisplay_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setTimeScale) + +static bool js_dragonBones_CCArmatureCacheDisplay_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((dragonBones::CCArmatureCacheDisplay const *)arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_getTimeScale) + +static bool js_dragonBones_CCArmatureCacheDisplay_beginSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSchedule(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_beginSchedule) + +static bool js_dragonBones_CCArmatureCacheDisplay_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_stopSchedule) + +static bool js_dragonBones_CCArmatureCacheDisplay_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_onEnable) + +static bool js_dragonBones_CCArmatureCacheDisplay_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_onDisable) + +static bool js_dragonBones_CCArmatureCacheDisplay_armature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + dragonBones::Armature *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Armature *)((dragonBones::CCArmatureCacheDisplay const *)arg1)->getArmature(); + + 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_dragonBones_CCArmatureCacheDisplay_armature) + +static bool js_dragonBones_CCArmatureCacheDisplay_getAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + dragonBones::Animation *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::Animation *)((dragonBones::CCArmatureCacheDisplay const *)arg1)->getAnimation(); + + 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_dragonBones_CCArmatureCacheDisplay_getAnimation) + +static bool js_dragonBones_CCArmatureCacheDisplay_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setColor) + +static bool js_dragonBones_CCArmatureCacheDisplay_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setBatchEnabled) + +static bool js_dragonBones_CCArmatureCacheDisplay_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setAttachEnabled) + +static bool js_dragonBones_CCArmatureCacheDisplay_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setOpacityModifyRGB) + +static bool js_dragonBones_CCArmatureCacheDisplay_setDBEventCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + dragonBones::CCArmatureCacheDisplay::dbEventCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDBEventCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setDBEventCallback) + +static bool js_dragonBones_CCArmatureCacheDisplay_addDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addDBEventListener((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_addDBEventListener) + +static bool js_dragonBones_CCArmatureCacheDisplay_removeDBEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeDBEventListener((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_removeDBEventListener) + +static bool js_dragonBones_CCArmatureCacheDisplay_dispatchDBEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + dragonBones::EventObject *arg3 = (dragonBones::EventObject *) NULL ; + std::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(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)->dispatchDBEvent((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_dispatchDBEvent) + +static bool js_dragonBones_CCArmatureCacheDisplay_playAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::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(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)->playAnimation((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_playAnimation) + +static bool js_dragonBones_CCArmatureCacheDisplay_updateAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateAnimationCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_updateAnimationCache) + +static bool js_dragonBones_CCArmatureCacheDisplay_updateAllAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateAllAnimationCache(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_updateAllAnimationCache) + +static bool js_dragonBones_CCArmatureCacheDisplay_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((dragonBones::CCArmatureCacheDisplay const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_getSharedBufferOffset) + +static bool js_dragonBones_CCArmatureCacheDisplay_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setMaterial) + +static bool js_dragonBones_CCArmatureCacheDisplay_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::CCArmatureCacheDisplay *arg1 = (dragonBones::CCArmatureCacheDisplay *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_CCArmatureCacheDisplay_setRenderEntity) + +bool js_register_dragonBones_CCArmatureCacheDisplay(se::Object* obj) { + auto* cls = se::Class::create("CCArmatureCacheDisplay", obj, nullptr, _SE(js_new_dragonBones_CCArmatureCacheDisplay)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("dispose", _SE(js_dragonBones_CCArmatureCacheDisplay_dispose)); + cls->defineFunction("update", _SE(js_dragonBones_CCArmatureCacheDisplay_update)); + cls->defineFunction("render", _SE(js_dragonBones_CCArmatureCacheDisplay_render)); + cls->defineFunction("setTimeScale", _SE(js_dragonBones_CCArmatureCacheDisplay_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_dragonBones_CCArmatureCacheDisplay_getTimeScale)); + cls->defineFunction("beginSchedule", _SE(js_dragonBones_CCArmatureCacheDisplay_beginSchedule)); + cls->defineFunction("stopSchedule", _SE(js_dragonBones_CCArmatureCacheDisplay_stopSchedule)); + cls->defineFunction("onEnable", _SE(js_dragonBones_CCArmatureCacheDisplay_onEnable)); + cls->defineFunction("onDisable", _SE(js_dragonBones_CCArmatureCacheDisplay_onDisable)); + cls->defineFunction("armature", _SE(js_dragonBones_CCArmatureCacheDisplay_armature)); + cls->defineFunction("getAnimation", _SE(js_dragonBones_CCArmatureCacheDisplay_getAnimation)); + cls->defineFunction("setColor", _SE(js_dragonBones_CCArmatureCacheDisplay_setColor)); + cls->defineFunction("setBatchEnabled", _SE(js_dragonBones_CCArmatureCacheDisplay_setBatchEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_dragonBones_CCArmatureCacheDisplay_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_dragonBones_CCArmatureCacheDisplay_setOpacityModifyRGB)); + cls->defineFunction("setDBEventCallback", _SE(js_dragonBones_CCArmatureCacheDisplay_setDBEventCallback)); + cls->defineFunction("addDBEventListener", _SE(js_dragonBones_CCArmatureCacheDisplay_addDBEventListener)); + cls->defineFunction("removeDBEventListener", _SE(js_dragonBones_CCArmatureCacheDisplay_removeDBEventListener)); + cls->defineFunction("dispatchDBEvent", _SE(js_dragonBones_CCArmatureCacheDisplay_dispatchDBEvent)); + cls->defineFunction("playAnimation", _SE(js_dragonBones_CCArmatureCacheDisplay_playAnimation)); + cls->defineFunction("updateAnimationCache", _SE(js_dragonBones_CCArmatureCacheDisplay_updateAnimationCache)); + cls->defineFunction("updateAllAnimationCache", _SE(js_dragonBones_CCArmatureCacheDisplay_updateAllAnimationCache)); + cls->defineFunction("getSharedBufferOffset", _SE(js_dragonBones_CCArmatureCacheDisplay_getSharedBufferOffset)); + cls->defineFunction("setMaterial", _SE(js_dragonBones_CCArmatureCacheDisplay_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_dragonBones_CCArmatureCacheDisplay_setRenderEntity)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_CCArmatureCacheDisplay)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_CCArmatureCacheDisplay_proto = cls->getProto(); + __jsb_dragonBones_CCArmatureCacheDisplay_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_ArmatureCache_class = nullptr; +se::Object* __jsb_dragonBones_ArmatureCache_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCache) + +static bool js_new_dragonBones_ArmatureCache(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp1 ; + std::string temp2 ; + std::string temp3 ; + dragonBones::ArmatureCache *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (dragonBones::ArmatureCache *)new dragonBones::ArmatureCache((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_ArmatureCache, __jsb_dragonBones_ArmatureCache_class, js_delete_dragonBones_ArmatureCache) + +static bool js_delete_dragonBones_ArmatureCache(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCache) + +static bool js_dragonBones_ArmatureCache_updateToFrame__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + int arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->updateToFrame((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_dragonBones_ArmatureCache_updateToFrame__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->updateToFrame((std::string const &)*arg2); + + + return true; +} + +static bool js_dragonBones_ArmatureCache_updateToFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_dragonBones_ArmatureCache_updateToFrame__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_dragonBones_ArmatureCache_updateToFrame__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCache_updateToFrame) + +static bool js_dragonBones_ArmatureCache_buildAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureCache::AnimationData *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(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 = (dragonBones::ArmatureCache::AnimationData *)(arg1)->buildAnimationData((std::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_dragonBones_ArmatureCache_buildAnimationData) + +static bool js_dragonBones_ArmatureCache_getAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + dragonBones::ArmatureCache::AnimationData *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(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 = (dragonBones::ArmatureCache::AnimationData *)(arg1)->getAnimationData((std::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_dragonBones_ArmatureCache_getAnimationData) + +static bool js_dragonBones_ArmatureCache_getArmatureDisplay(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + dragonBones::CCArmatureDisplay *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(s); + if (nullptr == arg1) return true; + result = (dragonBones::CCArmatureDisplay *)(arg1)->getArmatureDisplay(); + + 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_dragonBones_ArmatureCache_getArmatureDisplay) + +static bool js_dragonBones_ArmatureCache_resetAllAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetAllAnimationData(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCache_resetAllAnimationData) + +static bool js_dragonBones_ArmatureCache_resetAnimationData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCache *arg1 = (dragonBones::ArmatureCache *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resetAnimationData((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCache_resetAnimationData) + +bool js_register_dragonBones_ArmatureCache(se::Object* obj) { + auto* cls = se::Class::create("ArmatureCache", obj, nullptr, _SE(js_new_dragonBones_ArmatureCache)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateToFrame", _SE(js_dragonBones_ArmatureCache_updateToFrame)); + cls->defineFunction("buildAnimationData", _SE(js_dragonBones_ArmatureCache_buildAnimationData)); + cls->defineFunction("getAnimationData", _SE(js_dragonBones_ArmatureCache_getAnimationData)); + cls->defineFunction("getArmatureDisplay", _SE(js_dragonBones_ArmatureCache_getArmatureDisplay)); + cls->defineFunction("resetAllAnimationData", _SE(js_dragonBones_ArmatureCache_resetAllAnimationData)); + cls->defineFunction("resetAnimationData", _SE(js_dragonBones_ArmatureCache_resetAnimationData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_ArmatureCache)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_ArmatureCache_proto = cls->getProto(); + __jsb_dragonBones_ArmatureCache_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_dragonBones_ArmatureCacheMgr_class = nullptr; +se::Object* __jsb_dragonBones_ArmatureCacheMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCacheMgr) + +static bool js_dragonBones_ArmatureCacheMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCacheMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (dragonBones::ArmatureCacheMgr *)dragonBones::ArmatureCacheMgr::getInstance(); + + 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_dragonBones_ArmatureCacheMgr_getInstance_static) + +static bool js_dragonBones_ArmatureCacheMgr_destroyInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + dragonBones::ArmatureCacheMgr::destroyInstance(); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCacheMgr_destroyInstance_static) + +static bool js_dragonBones_ArmatureCacheMgr_removeArmatureCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCacheMgr *arg1 = (dragonBones::ArmatureCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeArmatureCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCacheMgr_removeArmatureCache) + +static bool js_dragonBones_ArmatureCacheMgr_buildArmatureCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + dragonBones::ArmatureCacheMgr *arg1 = (dragonBones::ArmatureCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string temp2 ; + std::string temp3 ; + std::string temp4 ; + dragonBones::ArmatureCache *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (dragonBones::ArmatureCache *)(arg1)->buildArmatureCache((std::string const &)*arg2,(std::string const &)*arg3,(std::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; +} +SE_BIND_FUNC(js_dragonBones_ArmatureCacheMgr_buildArmatureCache) + +static bool js_new_dragonBones_ArmatureCacheMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + dragonBones::ArmatureCacheMgr *result; + result = (dragonBones::ArmatureCacheMgr *)new dragonBones::ArmatureCacheMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_dragonBones_ArmatureCacheMgr, __jsb_dragonBones_ArmatureCacheMgr_class, js_delete_dragonBones_ArmatureCacheMgr) + +static bool js_delete_dragonBones_ArmatureCacheMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_dragonBones_ArmatureCacheMgr) + +bool js_register_dragonBones_ArmatureCacheMgr(se::Object* obj) { + auto* cls = se::Class::create("ArmatureCacheMgr", obj, nullptr, _SE(js_new_dragonBones_ArmatureCacheMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("removeArmatureCache", _SE(js_dragonBones_ArmatureCacheMgr_removeArmatureCache)); + cls->defineFunction("buildArmatureCache", _SE(js_dragonBones_ArmatureCacheMgr_buildArmatureCache)); + + + cls->defineStaticFunction("getInstance", _SE(js_dragonBones_ArmatureCacheMgr_getInstance_static)); + cls->defineStaticFunction("destroyInstance", _SE(js_dragonBones_ArmatureCacheMgr_destroyInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_dragonBones_ArmatureCacheMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_dragonBones_ArmatureCacheMgr_proto = cls->getProto(); + __jsb_dragonBones_ArmatureCacheMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_dragonbones(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("dragonBones", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("dragonBones", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_dragonBones_Rectangle(ns); + js_register_dragonBones_Transform(ns); + js_register_dragonBones_Matrix(ns); + js_register_dragonBones_BaseObject(ns); + js_register_dragonBones_EventObject(ns); + js_register_dragonBones_BaseFactory(ns); + js_register_dragonBones_BuildArmaturePackage(ns); + js_register_dragonBones_DragonBonesData(ns); + js_register_dragonBones_TextureAtlasData(ns); + js_register_dragonBones_TextureData(ns); + js_register_dragonBones_ArmatureData(ns); + js_register_dragonBones_BoneData(ns); + js_register_dragonBones_SlotData(ns); + js_register_dragonBones_SkinData(ns); + js_register_dragonBones_AnimationData(ns); + js_register_dragonBones_TimelineData(ns); + js_register_dragonBones_WorldClock(ns); + js_register_dragonBones_Animation(ns); + js_register_dragonBones_AnimationState(ns); + js_register_dragonBones_BonePose(ns); + js_register_dragonBones_BlendState(ns); + js_register_dragonBones_TransformObject(ns); + js_register_dragonBones_Slot(ns); + js_register_dragonBones_Bone(ns); + js_register_dragonBones_Armature(ns); + js_register_dragonBones_CCArmatureDisplay(ns); + js_register_dragonBones_CCFactory(ns); + js_register_dragonBones_CCSlot(ns); + js_register_dragonBones_CCArmatureCacheDisplay(ns); + js_register_dragonBones_ArmatureCache(ns); + js_register_dragonBones_ArmatureCacheMgr(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_dragonbones_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_dragonbones_auto.h new file mode 100644 index 0000000000..ef6df2be46 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_dragonbones_auto.h @@ -0,0 +1,199 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "editor-support/dragonbones-creator-support/CCDragonBonesHeaders.h" + + + +bool register_all_dragonbones(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Rectangle); +extern se::Object *__jsb_dragonBones_Rectangle_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Rectangle_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Transform); +extern se::Object *__jsb_dragonBones_Transform_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Transform_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Matrix); +extern se::Object *__jsb_dragonBones_Matrix_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Matrix_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BaseObject); +extern se::Object *__jsb_dragonBones_BaseObject_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BaseObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::EventObject); +extern se::Object *__jsb_dragonBones_EventObject_proto; // NOLINT +extern se::Class * __jsb_dragonBones_EventObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BaseFactory); +extern se::Object *__jsb_dragonBones_BaseFactory_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BaseFactory_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BuildArmaturePackage); +extern se::Object *__jsb_dragonBones_BuildArmaturePackage_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BuildArmaturePackage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::DragonBonesData); +extern se::Object *__jsb_dragonBones_DragonBonesData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_DragonBonesData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TextureAtlasData); +extern se::Object *__jsb_dragonBones_TextureAtlasData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TextureAtlasData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TextureData); +extern se::Object *__jsb_dragonBones_TextureData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TextureData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::ArmatureData); +extern se::Object *__jsb_dragonBones_ArmatureData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_ArmatureData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BoneData); +extern se::Object *__jsb_dragonBones_BoneData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BoneData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::SlotData); +extern se::Object *__jsb_dragonBones_SlotData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_SlotData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::SkinData); +extern se::Object *__jsb_dragonBones_SkinData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_SkinData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::AnimationData); +extern se::Object *__jsb_dragonBones_AnimationData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_AnimationData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TimelineData); +extern se::Object *__jsb_dragonBones_TimelineData_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TimelineData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::WorldClock); +extern se::Object *__jsb_dragonBones_WorldClock_proto; // NOLINT +extern se::Class * __jsb_dragonBones_WorldClock_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Animation); +extern se::Object *__jsb_dragonBones_Animation_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Animation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::AnimationState); +extern se::Object *__jsb_dragonBones_AnimationState_proto; // NOLINT +extern se::Class * __jsb_dragonBones_AnimationState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BonePose); +extern se::Object *__jsb_dragonBones_BonePose_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BonePose_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::BlendState); +extern se::Object *__jsb_dragonBones_BlendState_proto; // NOLINT +extern se::Class * __jsb_dragonBones_BlendState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::TransformObject); +extern se::Object *__jsb_dragonBones_TransformObject_proto; // NOLINT +extern se::Class * __jsb_dragonBones_TransformObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Slot); +extern se::Object *__jsb_dragonBones_Slot_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Slot_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Bone); +extern se::Object *__jsb_dragonBones_Bone_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Bone_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::Armature); +extern se::Object *__jsb_dragonBones_Armature_proto; // NOLINT +extern se::Class * __jsb_dragonBones_Armature_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCArmatureDisplay); +extern se::Object *__jsb_dragonBones_CCArmatureDisplay_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCArmatureDisplay_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCFactory); +extern se::Object *__jsb_dragonBones_CCFactory_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCFactory_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCSlot); +extern se::Object *__jsb_dragonBones_CCSlot_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCSlot_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::CCArmatureCacheDisplay); +extern se::Object *__jsb_dragonBones_CCArmatureCacheDisplay_proto; // NOLINT +extern se::Class * __jsb_dragonBones_CCArmatureCacheDisplay_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::ArmatureCache); +extern se::Object *__jsb_dragonBones_ArmatureCache_proto; // NOLINT +extern se::Class * __jsb_dragonBones_ArmatureCache_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(dragonBones::ArmatureCacheMgr); +extern se::Object *__jsb_dragonBones_ArmatureCacheMgr_proto; // NOLINT +extern se::Class * __jsb_dragonBones_ArmatureCacheMgr_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_editor_support_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_editor_support_auto.cpp new file mode 100644 index 0000000000..cc832ea39e --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_editor_support_auto.cpp @@ -0,0 +1,1159 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_editor_support_auto.h" + + + +se::Class* __jsb_cc_middleware_Texture2D_class = nullptr; +se::Object* __jsb_cc_middleware_Texture2D_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_Texture2D) + +static bool js_new_cc_middleware_Texture2D(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::middleware::Texture2D *result; + result = (cc::middleware::Texture2D *)new cc::middleware::Texture2D(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_Texture2D, __jsb_cc_middleware_Texture2D_class, js_delete_cc_middleware_Texture2D) + +static bool js_delete_cc_middleware_Texture2D(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_Texture2D) + +static bool js_cc_middleware_Texture2D_getPixelsWide(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::middleware::Texture2D const *)arg1)->getPixelsWide(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_getPixelsWide) + +static bool js_cc_middleware_Texture2D_getPixelsHigh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::middleware::Texture2D const *)arg1)->getPixelsHigh(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_getPixelsHigh) + +static bool js_cc_middleware_Texture2D_getRealTextureIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::middleware::Texture2D const *)arg1)->getRealTextureIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_getRealTextureIndex) + +static bool js_cc_middleware_Texture2D_setPixelsWide(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPixelsWide(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setPixelsWide) + +static bool js_cc_middleware_Texture2D_setPixelsHigh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPixelsHigh(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setPixelsHigh) + +static bool js_cc_middleware_Texture2D_setRealTextureIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRealTextureIndex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setRealTextureIndex) + +static bool js_cc_middleware_Texture2D_setTexParamCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + cc::middleware::Texture2D::texParamCallback *arg2 = 0 ; + cc::middleware::Texture2D::texParamCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setTexParamCallback((cc::middleware::Texture2D::texParamCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setTexParamCallback) + +static bool js_cc_middleware_Texture2D_setRealTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRealTexture(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_Texture2D_setRealTexture) + +static bool js_cc_middleware_Texture2D_getRealTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((cc::middleware::Texture2D const *)arg1)->getRealTexture(); + + 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_middleware_Texture2D_getRealTexture) + +bool js_register_cc_middleware_Texture2D(se::Object* obj) { + auto* cls = se::Class::create("Texture2D", obj, nullptr, _SE(js_new_cc_middleware_Texture2D)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getPixelsWide", _SE(js_cc_middleware_Texture2D_getPixelsWide)); + cls->defineFunction("getPixelsHigh", _SE(js_cc_middleware_Texture2D_getPixelsHigh)); + cls->defineFunction("getRealTextureIndex", _SE(js_cc_middleware_Texture2D_getRealTextureIndex)); + cls->defineFunction("setPixelsWide", _SE(js_cc_middleware_Texture2D_setPixelsWide)); + cls->defineFunction("setPixelsHigh", _SE(js_cc_middleware_Texture2D_setPixelsHigh)); + cls->defineFunction("setRealTextureIndex", _SE(js_cc_middleware_Texture2D_setRealTextureIndex)); + cls->defineFunction("setTexParamCallback", _SE(js_cc_middleware_Texture2D_setTexParamCallback)); + cls->defineFunction("setRealTexture", _SE(js_cc_middleware_Texture2D_setRealTexture)); + cls->defineFunction("getRealTexture", _SE(js_cc_middleware_Texture2D_getRealTexture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_Texture2D)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_Texture2D_proto = cls->getProto(); + __jsb_cc_middleware_Texture2D_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_middleware_SpriteFrame_class = nullptr; +se::Object* __jsb_cc_middleware_SpriteFrame_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_SpriteFrame) + +static bool js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg2 = 0 ; + cc::Rect temp2 ; + cc::middleware::SpriteFrame *result = 0 ; + + + 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::middleware::SpriteFrame *)cc::middleware::SpriteFrame::createWithTexture(arg1,(cc::Rect 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; +} + +static bool js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::Texture2D *arg1 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg2 = 0 ; + bool arg3 ; + cc::Vec2 *arg4 = 0 ; + cc::Size *arg5 = 0 ; + cc::Rect temp2 ; + cc::Vec2 temp4 ; + cc::Size temp5 ; + cc::middleware::SpriteFrame *result = 0 ; + + + 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; + + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[4], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + result = (cc::middleware::SpriteFrame *)cc::middleware::SpriteFrame::createWithTexture(arg1,(cc::Rect const &)*arg2,arg3,(cc::Vec2 const &)*arg4,(cc::Size const &)*arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_middleware_SpriteFrame_createWithTexture_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_middleware_SpriteFrame_createWithTexture_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_middleware_SpriteFrame_createWithTexture_static) + +static bool js_new_cc_middleware_SpriteFrame(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::middleware::SpriteFrame *result; + result = (cc::middleware::SpriteFrame *)new cc::middleware::SpriteFrame(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_SpriteFrame, __jsb_cc_middleware_SpriteFrame_class, js_delete_cc_middleware_SpriteFrame) + +static bool js_delete_cc_middleware_SpriteFrame(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_SpriteFrame) + +static bool js_cc_middleware_SpriteFrame_initWithTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *arg2 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg3 = 0 ; + cc::Rect temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->initWithTexture(arg2,(cc::Rect const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_middleware_SpriteFrame_initWithTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *arg2 = (cc::middleware::Texture2D *) NULL ; + cc::Rect *arg3 = 0 ; + bool arg4 ; + cc::Vec2 *arg5 = 0 ; + cc::Size *arg6 = 0 ; + cc::Rect temp3 ; + cc::Vec2 temp5 ; + cc::Size temp6 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (bool)(arg1)->initWithTexture(arg2,(cc::Rect const &)*arg3,arg4,(cc::Vec2 const &)*arg5,(cc::Size const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_middleware_SpriteFrame_initWithTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_middleware_SpriteFrame_initWithTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_middleware_SpriteFrame_initWithTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_middleware_SpriteFrame_initWithTexture) + +static bool js_cc_middleware_SpriteFrame_getTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *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(s); + if (nullptr == arg1) return true; + result = (cc::middleware::Texture2D *)(arg1)->getTexture(); + + 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_middleware_SpriteFrame_getTexture) + +static bool js_cc_middleware_SpriteFrame_setTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SpriteFrame *arg1 = (cc::middleware::SpriteFrame *) NULL ; + cc::middleware::Texture2D *arg2 = (cc::middleware::Texture2D *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTexture(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_SpriteFrame_setTexture) + +bool js_register_cc_middleware_SpriteFrame(se::Object* obj) { + auto* cls = se::Class::create("SpriteFrame", obj, nullptr, _SE(js_new_cc_middleware_SpriteFrame)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initWithTexture", _SE(js_cc_middleware_SpriteFrame_initWithTexture)); + cls->defineFunction("getTexture", _SE(js_cc_middleware_SpriteFrame_getTexture)); + cls->defineFunction("setTexture", _SE(js_cc_middleware_SpriteFrame_setTexture)); + + + cls->defineStaticFunction("createWithTexture", _SE(js_cc_middleware_SpriteFrame_createWithTexture_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_SpriteFrame)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_SpriteFrame_proto = cls->getProto(); + __jsb_cc_middleware_SpriteFrame_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_middleware_SharedBufferManager_class = nullptr; +se::Object* __jsb_cc_middleware_SharedBufferManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_SharedBufferManager) + +static bool js_new_cc_middleware_SharedBufferManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + se::Object::TypedArrayType arg1 ; + cc::middleware::SharedBufferManager *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::middleware::SharedBufferManager *)new cc::middleware::SharedBufferManager(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_SharedBufferManager, __jsb_cc_middleware_SharedBufferManager_class, js_delete_cc_middleware_SharedBufferManager) + +static bool js_delete_cc_middleware_SharedBufferManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_SharedBufferManager) + +static bool js_cc_middleware_SharedBufferManager_setResizeCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SharedBufferManager *arg1 = (cc::middleware::SharedBufferManager *) NULL ; + cc::middleware::SharedBufferManager::resizeCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setResizeCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_SharedBufferManager_setResizeCallback) + +static bool js_cc_middleware_SharedBufferManager_getSharedBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::SharedBufferManager *arg1 = (cc::middleware::SharedBufferManager *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::middleware::SharedBufferManager const *)arg1)->getSharedBuffer(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_SharedBufferManager_getSharedBuffer) + +bool js_register_cc_middleware_SharedBufferManager(se::Object* obj) { + auto* cls = se::Class::create("SharedBufferManager", obj, nullptr, _SE(js_new_cc_middleware_SharedBufferManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setResizeCallback", _SE(js_cc_middleware_SharedBufferManager_setResizeCallback)); + cls->defineFunction("getSharedBuffer", _SE(js_cc_middleware_SharedBufferManager_getSharedBuffer)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_SharedBufferManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_SharedBufferManager_proto = cls->getProto(); + __jsb_cc_middleware_SharedBufferManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_middleware_MiddlewareManager_class = nullptr; +se::Object* __jsb_cc_middleware_MiddlewareManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_middleware_MiddlewareManager) + +static bool js_cc_middleware_MiddlewareManager_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::middleware::MiddlewareManager *)cc::middleware::MiddlewareManager::getInstance(); + + 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_middleware_MiddlewareManager_getInstance_static) + +static bool js_cc_middleware_MiddlewareManager_destroyInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::middleware::MiddlewareManager::destroyInstance(); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_destroyInstance_static) + +static bool js_cc_middleware_MiddlewareManager_generateModuleID_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint8_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = cc::middleware::MiddlewareManager::generateModuleID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_generateModuleID_static) + +static bool js_cc_middleware_MiddlewareManager_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_update) + +static bool js_cc_middleware_MiddlewareManager_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_render) + +static bool js_cc_middleware_MiddlewareManager_getVBTypedArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + int arg3 ; + se_object_ptr result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getVBTypedArray(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getVBTypedArray) + +static bool js_cc_middleware_MiddlewareManager_getIBTypedArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + int arg3 ; + se_object_ptr result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->getIBTypedArray(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getIBTypedArray) + +static bool js_cc_middleware_MiddlewareManager_getBufferCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + std::size_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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getBufferCount(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getBufferCount) + +static bool js_cc_middleware_MiddlewareManager_getVBTypedArrayLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + std::size_t arg3 ; + std::size_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(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 = (arg1)->getVBTypedArrayLength(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getVBTypedArrayLength) + +static bool js_cc_middleware_MiddlewareManager_getIBTypedArrayLength(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + int arg2 ; + std::size_t arg3 ; + std::size_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(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 = (arg1)->getIBTypedArrayLength(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_middleware_MiddlewareManager_getIBTypedArrayLength) + +static bool js_cc_middleware_MiddlewareManager_getRenderInfoMgr(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + cc::middleware::SharedBufferManager *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(s); + if (nullptr == arg1) return true; + result = (cc::middleware::SharedBufferManager *)(arg1)->getRenderInfoMgr(); + + 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_middleware_MiddlewareManager_getRenderInfoMgr) + +static bool js_cc_middleware_MiddlewareManager_getAttachInfoMgr(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::middleware::MiddlewareManager *arg1 = (cc::middleware::MiddlewareManager *) NULL ; + cc::middleware::SharedBufferManager *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(s); + if (nullptr == arg1) return true; + result = (cc::middleware::SharedBufferManager *)(arg1)->getAttachInfoMgr(); + + 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_middleware_MiddlewareManager_getAttachInfoMgr) + +static bool js_new_cc_middleware_MiddlewareManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::middleware::MiddlewareManager *result; + result = (cc::middleware::MiddlewareManager *)new cc::middleware::MiddlewareManager(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_middleware_MiddlewareManager, __jsb_cc_middleware_MiddlewareManager_class, js_delete_cc_middleware_MiddlewareManager) + +static bool js_delete_cc_middleware_MiddlewareManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_middleware_MiddlewareManager) + +bool js_register_cc_middleware_MiddlewareManager(se::Object* obj) { + auto* cls = se::Class::create("MiddlewareManager", obj, nullptr, _SE(js_new_cc_middleware_MiddlewareManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_middleware_MiddlewareManager_update)); + cls->defineFunction("render", _SE(js_cc_middleware_MiddlewareManager_render)); + cls->defineFunction("getVBTypedArray", _SE(js_cc_middleware_MiddlewareManager_getVBTypedArray)); + cls->defineFunction("getIBTypedArray", _SE(js_cc_middleware_MiddlewareManager_getIBTypedArray)); + cls->defineFunction("getBufferCount", _SE(js_cc_middleware_MiddlewareManager_getBufferCount)); + cls->defineFunction("getVBTypedArrayLength", _SE(js_cc_middleware_MiddlewareManager_getVBTypedArrayLength)); + cls->defineFunction("getIBTypedArrayLength", _SE(js_cc_middleware_MiddlewareManager_getIBTypedArrayLength)); + cls->defineFunction("getRenderInfoMgr", _SE(js_cc_middleware_MiddlewareManager_getRenderInfoMgr)); + cls->defineFunction("getAttachInfoMgr", _SE(js_cc_middleware_MiddlewareManager_getAttachInfoMgr)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_middleware_MiddlewareManager_getInstance_static)); + cls->defineStaticFunction("destroyInstance", _SE(js_cc_middleware_MiddlewareManager_destroyInstance_static)); + cls->defineStaticFunction("generateModuleID", _SE(js_cc_middleware_MiddlewareManager_generateModuleID_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_middleware_MiddlewareManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_middleware_MiddlewareManager_proto = cls->getProto(); + __jsb_cc_middleware_MiddlewareManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_editor_support(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("middleware", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("middleware", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_middleware_Texture2D(ns); + js_register_cc_middleware_SpriteFrame(ns); + js_register_cc_middleware_SharedBufferManager(ns); + js_register_cc_middleware_MiddlewareManager(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_editor_support_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_editor_support_auto.h new file mode 100644 index 0000000000..e788ecba6b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_editor_support_auto.h @@ -0,0 +1,67 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "editor-support/middleware-adapter.h" +#include "editor-support/MiddlewareManager.h" +#include "editor-support/SharedBufferManager.h" + + + + +bool register_all_editor_support(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::Texture2D); +extern se::Object *__jsb_cc_middleware_Texture2D_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_Texture2D_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::SpriteFrame); +extern se::Object *__jsb_cc_middleware_SpriteFrame_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_SpriteFrame_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::SharedBufferManager); +extern se::Object *__jsb_cc_middleware_SharedBufferManager_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_SharedBufferManager_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::middleware::MiddlewareManager); +extern se::Object *__jsb_cc_middleware_MiddlewareManager_proto; // NOLINT +extern se::Class * __jsb_cc_middleware_MiddlewareManager_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_extension_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_extension_auto.cpp new file mode 100644 index 0000000000..6486aeb598 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_extension_auto.cpp @@ -0,0 +1,2522 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_extension_auto.h" + + + +se::Class* __jsb_cc_extension_EventAssetsManagerEx_class = nullptr; +se::Object* __jsb_cc_extension_EventAssetsManagerEx_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_EventAssetsManagerEx) + +static bool js_cc_extension_EventAssetsManager_getEventCode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::extension::EventAssetsManagerEx::EventCode)((cc::extension::EventAssetsManagerEx const *)arg1)->getEventCode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getEventCode) + +static bool js_cc_extension_EventAssetsManager_getCURLECode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getCURLECode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getCURLECode) + +static bool js_cc_extension_EventAssetsManager_getCURLMCode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getCURLMCode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getCURLMCode) + +static bool js_cc_extension_EventAssetsManager_getMessage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + std::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::extension::EventAssetsManagerEx const *)arg1)->getMessage(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getMessage) + +static bool js_cc_extension_EventAssetsManager_getAssetId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + std::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::extension::EventAssetsManagerEx const *)arg1)->getAssetId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getAssetId) + +static bool js_cc_extension_EventAssetsManager_getAssetsManagerEx(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx *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(s); + if (nullptr == arg1) return true; + result = (cc::extension::AssetsManagerEx *)((cc::extension::EventAssetsManagerEx const *)arg1)->getAssetsManagerEx(); + + 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_extension_EventAssetsManager_getAssetsManagerEx) + +static bool js_cc_extension_EventAssetsManager_isResuming(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::EventAssetsManagerEx const *)arg1)->isResuming(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_isResuming) + +static bool js_cc_extension_EventAssetsManager_getPercent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::extension::EventAssetsManagerEx const *)arg1)->getPercent(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getPercent) + +static bool js_cc_extension_EventAssetsManager_getPercentByFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::extension::EventAssetsManagerEx const *)arg1)->getPercentByFile(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getPercentByFile) + +static bool js_cc_extension_EventAssetsManager_getDownloadedBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::EventAssetsManagerEx const *)arg1)->getDownloadedBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getDownloadedBytes) + +static bool js_cc_extension_EventAssetsManager_getTotalBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::EventAssetsManagerEx const *)arg1)->getTotalBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getTotalBytes) + +static bool js_cc_extension_EventAssetsManager_getDownloadedFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getDownloadedFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getDownloadedFiles) + +static bool js_cc_extension_EventAssetsManager_getTotalFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::EventAssetsManagerEx *arg1 = (cc::extension::EventAssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::EventAssetsManagerEx const *)arg1)->getTotalFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_EventAssetsManager_getTotalFiles) + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string arg5 ; + int arg6 ; + int arg7 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string arg5 ; + int arg6 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string arg5 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string arg4 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + cc::extension::AssetsManagerEx *arg2 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::EventAssetsManagerEx::EventCode arg3 ; + std::string temp1 ; + cc::extension::EventAssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::EventAssetsManagerEx *)new cc::extension::EventAssetsManagerEx((std::string const &)*arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_EventAssetsManagerEx(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 7) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 6) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_extension_EventAssetsManagerEx__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of EventAssetsManager"); + return false; +} +SE_BIND_CTOR(js_new_cc_extension_EventAssetsManagerEx, __jsb_cc_extension_EventAssetsManagerEx_class, js_delete_cc_extension_EventAssetsManagerEx) + +static bool js_delete_cc_extension_EventAssetsManagerEx(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_EventAssetsManagerEx) + +bool js_register_cc_extension_EventAssetsManagerEx(se::Object* obj) { + auto* cls = se::Class::create("EventAssetsManager", obj, nullptr, _SE(js_new_cc_extension_EventAssetsManagerEx)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getEventCode", _SE(js_cc_extension_EventAssetsManager_getEventCode)); + cls->defineFunction("getCURLECode", _SE(js_cc_extension_EventAssetsManager_getCURLECode)); + cls->defineFunction("getCURLMCode", _SE(js_cc_extension_EventAssetsManager_getCURLMCode)); + cls->defineFunction("getMessage", _SE(js_cc_extension_EventAssetsManager_getMessage)); + cls->defineFunction("getAssetId", _SE(js_cc_extension_EventAssetsManager_getAssetId)); + cls->defineFunction("getAssetsManagerEx", _SE(js_cc_extension_EventAssetsManager_getAssetsManagerEx)); + cls->defineFunction("isResuming", _SE(js_cc_extension_EventAssetsManager_isResuming)); + cls->defineFunction("getPercent", _SE(js_cc_extension_EventAssetsManager_getPercent)); + cls->defineFunction("getPercentByFile", _SE(js_cc_extension_EventAssetsManager_getPercentByFile)); + cls->defineFunction("getDownloadedBytes", _SE(js_cc_extension_EventAssetsManager_getDownloadedBytes)); + cls->defineFunction("getTotalBytes", _SE(js_cc_extension_EventAssetsManager_getTotalBytes)); + cls->defineFunction("getDownloadedFiles", _SE(js_cc_extension_EventAssetsManager_getDownloadedFiles)); + cls->defineFunction("getTotalFiles", _SE(js_cc_extension_EventAssetsManager_getTotalFiles)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_EventAssetsManagerEx)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_EventAssetsManagerEx_proto = cls->getProto(); + __jsb_cc_extension_EventAssetsManagerEx_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_DownloadUnit_class = nullptr; +se::Object* __jsb_cc_extension_DownloadUnit_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_DownloadUnit) + +static bool js_cc_extension_DownloadUnit_srcUrl_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcUrl, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_srcUrl_set) + +static bool js_cc_extension_DownloadUnit_srcUrl_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcUrl, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcUrl, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_srcUrl_get) + +static bool js_cc_extension_DownloadUnit_storagePath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storagePath, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_storagePath_set) + +static bool js_cc_extension_DownloadUnit_storagePath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storagePath, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storagePath, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_storagePath_get) + +static bool js_cc_extension_DownloadUnit_customId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->customId, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_customId_set) + +static bool js_cc_extension_DownloadUnit_customId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->customId, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->customId, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_customId_get) + +static bool js_cc_extension_DownloadUnit_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_DownloadUnit_size_set) + +static bool js_cc_extension_DownloadUnit_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::DownloadUnit *arg1 = (cc::extension::DownloadUnit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_DownloadUnit_size_get) + +static bool js_new_cc_extension_DownloadUnit(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::extension::DownloadUnit *result; + result = (cc::extension::DownloadUnit *)new cc::extension::DownloadUnit(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_extension_DownloadUnit, __jsb_cc_extension_DownloadUnit_class, js_delete_cc_extension_DownloadUnit) + +static bool js_delete_cc_extension_DownloadUnit(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_DownloadUnit) + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::DownloadUnit * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcUrl", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcUrl), ctx); + } + + + json->getProperty("storagePath", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->storagePath), ctx); + } + + + json->getProperty("customId", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->customId), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + return ok; +} + + +bool js_register_cc_extension_DownloadUnit(se::Object* obj) { + auto* cls = se::Class::create("DownloadUnit", obj, nullptr, _SE(js_new_cc_extension_DownloadUnit)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcUrl", _SE(js_cc_extension_DownloadUnit_srcUrl_get), _SE(js_cc_extension_DownloadUnit_srcUrl_set)); + cls->defineProperty("storagePath", _SE(js_cc_extension_DownloadUnit_storagePath_get), _SE(js_cc_extension_DownloadUnit_storagePath_set)); + cls->defineProperty("customId", _SE(js_cc_extension_DownloadUnit_customId_get), _SE(js_cc_extension_DownloadUnit_customId_set)); + cls->defineProperty("size", _SE(js_cc_extension_DownloadUnit_size_get), _SE(js_cc_extension_DownloadUnit_size_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_DownloadUnit)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_DownloadUnit_proto = cls->getProto(); + __jsb_cc_extension_DownloadUnit_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_ManifestAsset_class = nullptr; +se::Object* __jsb_cc_extension_ManifestAsset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_ManifestAsset) + +static bool js_cc_extension_ManifestAsset_md5_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->md5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_md5_set) + +static bool js_cc_extension_ManifestAsset_md5_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->md5, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->md5, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_md5_get) + +static bool js_cc_extension_ManifestAsset_path_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->path, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_path_set) + +static bool js_cc_extension_ManifestAsset_path_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->path, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->path, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_path_get) + +static bool js_cc_extension_ManifestAsset_compressed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compressed); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_compressed_set) + +static bool js_cc_extension_ManifestAsset_compressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compressed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_compressed_get) + +static bool js_cc_extension_ManifestAsset_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_size_set) + +static bool js_cc_extension_ManifestAsset_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_size_get) + +static bool js_cc_extension_ManifestAsset_downloadState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->downloadState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_ManifestAsset_downloadState_set) + +static bool js_cc_extension_ManifestAsset_downloadState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::ManifestAsset *arg1 = (cc::extension::ManifestAsset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->downloadState, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_ManifestAsset_downloadState_get) + +static bool js_new_cc_extension_ManifestAsset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::extension::ManifestAsset *result; + result = (cc::extension::ManifestAsset *)new cc::extension::ManifestAsset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_extension_ManifestAsset, __jsb_cc_extension_ManifestAsset_class, js_delete_cc_extension_ManifestAsset) + +static bool js_delete_cc_extension_ManifestAsset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_ManifestAsset) + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::ManifestAsset * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("md5", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->md5), ctx); + } + + + json->getProperty("path", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->path), ctx); + } + + + json->getProperty("compressed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compressed), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("downloadState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->downloadState), ctx); + } + + + return ok; +} + + +bool js_register_cc_extension_ManifestAsset(se::Object* obj) { + auto* cls = se::Class::create("ManifestAsset", obj, nullptr, _SE(js_new_cc_extension_ManifestAsset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("md5", _SE(js_cc_extension_ManifestAsset_md5_get), _SE(js_cc_extension_ManifestAsset_md5_set)); + cls->defineProperty("path", _SE(js_cc_extension_ManifestAsset_path_get), _SE(js_cc_extension_ManifestAsset_path_set)); + cls->defineProperty("compressed", _SE(js_cc_extension_ManifestAsset_compressed_get), _SE(js_cc_extension_ManifestAsset_compressed_set)); + cls->defineProperty("size", _SE(js_cc_extension_ManifestAsset_size_get), _SE(js_cc_extension_ManifestAsset_size_set)); + cls->defineProperty("downloadState", _SE(js_cc_extension_ManifestAsset_downloadState_get), _SE(js_cc_extension_ManifestAsset_downloadState_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_ManifestAsset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_ManifestAsset_proto = cls->getProto(); + __jsb_cc_extension_ManifestAsset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_Manifest_class = nullptr; +se::Object* __jsb_cc_extension_Manifest_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_Manifest) + +se::Class* __jsb_cc_extension_Manifest_AssetDiff_class = nullptr; +se::Object* __jsb_cc_extension_Manifest_AssetDiff_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_Manifest_AssetDiff) + +static bool js_cc_extension_Manifest_AssetDiff_asset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->asset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_Manifest_AssetDiff_asset_set) + +static bool js_cc_extension_Manifest_AssetDiff_asset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->asset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->asset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_Manifest_AssetDiff_asset_get) + +static bool js_cc_extension_Manifest_AssetDiff_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_extension_Manifest_AssetDiff_type_set) + +static bool js_cc_extension_Manifest_AssetDiff_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::extension::Manifest::AssetDiff *arg1 = (cc::extension::Manifest::AssetDiff *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_extension_Manifest_AssetDiff_type_get) + +static bool js_new_cc_extension_Manifest_AssetDiff(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::extension::Manifest::AssetDiff *result; + result = (cc::extension::Manifest::AssetDiff *)new cc::extension::Manifest::AssetDiff(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_extension_Manifest_AssetDiff, __jsb_cc_extension_Manifest_AssetDiff_class, js_delete_cc_extension_Manifest_AssetDiff) + +static bool js_delete_cc_extension_Manifest_AssetDiff(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_Manifest_AssetDiff) + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::Manifest::AssetDiff * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("asset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->asset), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + return ok; +} + + +bool js_register_cc_extension_Manifest_AssetDiff(se::Object* obj) { + auto* cls = se::Class::create({"Manifest", "AssetDiff"}, obj, nullptr, _SE(js_new_cc_extension_Manifest_AssetDiff)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("asset", _SE(js_cc_extension_Manifest_AssetDiff_asset_get), _SE(js_cc_extension_Manifest_AssetDiff_asset_set)); + cls->defineProperty("type", _SE(js_cc_extension_Manifest_AssetDiff_type_get), _SE(js_cc_extension_Manifest_AssetDiff_type_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_Manifest_AssetDiff)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_Manifest_AssetDiff_proto = cls->getProto(); + __jsb_cc_extension_Manifest_AssetDiff_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_extension_Manifest_isVersionLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::Manifest const *)arg1)->isVersionLoaded(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_isVersionLoaded) + +static bool js_cc_extension_Manifest_isLoaded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::Manifest const *)arg1)->isLoaded(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_isLoaded) + +static bool js_cc_extension_Manifest_getPackageUrl(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getPackageUrl(); + + 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_extension_Manifest_getPackageUrl) + +static bool js_cc_extension_Manifest_getManifestFileUrl(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getManifestFileUrl(); + + 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_extension_Manifest_getManifestFileUrl) + +static bool js_cc_extension_Manifest_getVersionFileUrl(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getVersionFileUrl(); + + 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_extension_Manifest_getVersionFileUrl) + +static bool js_cc_extension_Manifest_getVersion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getVersion(); + + 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_extension_Manifest_getVersion) + +static bool js_cc_extension_Manifest_getSearchPaths(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::vector< std::string > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::extension::Manifest const *)arg1)->getSearchPaths(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_getSearchPaths) + +static bool js_cc_extension_Manifest_getManifestRoot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::Manifest const *)arg1)->getManifestRoot(); + + 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_extension_Manifest_getManifestRoot) + +static bool js_new_cc_extension_Manifest__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string temp1 ; + cc::extension::Manifest *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::extension::Manifest *)new cc::extension::Manifest((std::string const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_Manifest__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::extension::Manifest *result; + result = (cc::extension::Manifest *)new cc::extension::Manifest(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_Manifest__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::Manifest *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::extension::Manifest *)new cc::extension::Manifest((std::string const &)*arg1,(std::string const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_Manifest(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_cc_extension_Manifest__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_extension_Manifest__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_extension_Manifest__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Manifest"); + return false; +} +SE_BIND_CTOR(js_new_cc_extension_Manifest, __jsb_cc_extension_Manifest_class, js_delete_cc_extension_Manifest) + +static bool js_cc_extension_Manifest_parseFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->parseFile((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_parseFile) + +static bool js_cc_extension_Manifest_parseJSONString(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::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(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)->parseJSONString((std::string const &)*arg2,(std::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_parseJSONString) + +static bool js_cc_extension_Manifest_isUpdating(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::Manifest const *)arg1)->isUpdating(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_isUpdating) + +static bool js_cc_extension_Manifest_setUpdating(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::Manifest *arg1 = (cc::extension::Manifest *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUpdating(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_Manifest_setUpdating) + +static bool js_delete_cc_extension_Manifest(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_Manifest) + +bool js_register_cc_extension_Manifest(se::Object* obj) { + auto* cls = se::Class::create("Manifest", obj, nullptr, _SE(js_new_cc_extension_Manifest)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("isVersionLoaded", _SE(js_cc_extension_Manifest_isVersionLoaded)); + cls->defineFunction("isLoaded", _SE(js_cc_extension_Manifest_isLoaded)); + cls->defineFunction("getPackageUrl", _SE(js_cc_extension_Manifest_getPackageUrl)); + cls->defineFunction("getManifestFileUrl", _SE(js_cc_extension_Manifest_getManifestFileUrl)); + cls->defineFunction("getVersionFileUrl", _SE(js_cc_extension_Manifest_getVersionFileUrl)); + cls->defineFunction("getVersion", _SE(js_cc_extension_Manifest_getVersion)); + cls->defineFunction("getSearchPaths", _SE(js_cc_extension_Manifest_getSearchPaths)); + cls->defineFunction("getManifestRoot", _SE(js_cc_extension_Manifest_getManifestRoot)); + cls->defineFunction("parseFile", _SE(js_cc_extension_Manifest_parseFile)); + cls->defineFunction("parseJSONString", _SE(js_cc_extension_Manifest_parseJSONString)); + cls->defineFunction("isUpdating", _SE(js_cc_extension_Manifest_isUpdating)); + cls->defineFunction("setUpdating", _SE(js_cc_extension_Manifest_setUpdating)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_Manifest)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_Manifest_proto = cls->getProto(); + __jsb_cc_extension_Manifest_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_extension_AssetsManagerEx_class = nullptr; +se::Object* __jsb_cc_extension_AssetsManagerEx_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_extension_AssetsManagerEx) + +static bool js_cc_extension_AssetsManager_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::AssetsManagerEx *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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::extension::AssetsManagerEx *)cc::extension::AssetsManagerEx::create((std::string const &)*arg1,(std::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_extension_AssetsManager_create_static) + +static bool js_new_cc_extension_AssetsManagerEx__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::AssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::extension::AssetsManagerEx *)new cc::extension::AssetsManagerEx((std::string const &)*arg1,(std::string const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_AssetsManagerEx__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + cc::extension::AssetsManagerEx::VersionCompareHandle arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::extension::AssetsManagerEx *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::extension::AssetsManagerEx *)new cc::extension::AssetsManagerEx((std::string const &)*arg1,(std::string const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_extension_AssetsManagerEx(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 2) { + ret = js_new_cc_extension_AssetsManagerEx__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_extension_AssetsManagerEx__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of AssetsManager"); + return false; +} +SE_BIND_CTOR(js_new_cc_extension_AssetsManagerEx, __jsb_cc_extension_AssetsManagerEx_class, js_delete_cc_extension_AssetsManagerEx) + +static bool js_delete_cc_extension_AssetsManagerEx(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_extension_AssetsManagerEx) + +static bool js_cc_extension_AssetsManager_checkUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->checkUpdate(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_checkUpdate) + +static bool js_cc_extension_AssetsManager_prepareUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->prepareUpdate(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_prepareUpdate) + +static bool js_cc_extension_AssetsManager_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_update) + +static bool js_cc_extension_AssetsManager_downloadFailedAssets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->downloadFailedAssets(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_downloadFailedAssets) + +static bool js_cc_extension_AssetsManager_getState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::State result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::extension::AssetsManagerEx::State)((cc::extension::AssetsManagerEx const *)arg1)->getState(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getState) + +static bool js_cc_extension_AssetsManager_getStoragePath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::extension::AssetsManagerEx const *)arg1)->getStoragePath(); + + 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_extension_AssetsManager_getStoragePath) + +static bool js_cc_extension_AssetsManager_getLocalManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *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(s); + if (nullptr == arg1) return true; + result = (cc::extension::Manifest *)((cc::extension::AssetsManagerEx const *)arg1)->getLocalManifest(); + + 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_extension_AssetsManager_getLocalManifest) + +static bool js_cc_extension_AssetsManager_loadLocalManifest__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *arg2 = (cc::extension::Manifest *) NULL ; + std::string *arg3 = 0 ; + std::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->loadLocalManifest(arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_extension_AssetsManager_loadLocalManifest__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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)(arg1)->loadLocalManifest((std::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_extension_AssetsManager_loadLocalManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_extension_AssetsManager_loadLocalManifest__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_extension_AssetsManager_loadLocalManifest__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_loadLocalManifest) + +static bool js_cc_extension_AssetsManager_getRemoteManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *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(s); + if (nullptr == arg1) return true; + result = (cc::extension::Manifest *)((cc::extension::AssetsManagerEx const *)arg1)->getRemoteManifest(); + + 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_extension_AssetsManager_getRemoteManifest) + +static bool js_cc_extension_AssetsManager_loadRemoteManifest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::Manifest *arg2 = (cc::extension::Manifest *) 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(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)->loadRemoteManifest(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_loadRemoteManifest) + +static bool js_cc_extension_AssetsManager_isResuming(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::extension::AssetsManagerEx const *)arg1)->isResuming(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_isResuming) + +static bool js_cc_extension_AssetsManager_getTotalBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::AssetsManagerEx const *)arg1)->getTotalBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getTotalBytes) + +static bool js_cc_extension_AssetsManager_getDownloadedBytes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + double result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (double)((cc::extension::AssetsManagerEx const *)arg1)->getDownloadedBytes(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getDownloadedBytes) + +static bool js_cc_extension_AssetsManager_getTotalFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getTotalFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getTotalFiles) + +static bool js_cc_extension_AssetsManager_getDownloadedFiles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getDownloadedFiles(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getDownloadedFiles) + +static bool js_cc_extension_AssetsManager_getMaxConcurrentTask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((cc::extension::AssetsManagerEx const *)arg1)->getMaxConcurrentTask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_getMaxConcurrentTask) + +static bool js_cc_extension_AssetsManager_setMaxConcurrentTask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaxConcurrentTask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setMaxConcurrentTask) + +static bool js_cc_extension_AssetsManager_setVersionCompareHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::VersionCompareHandle *arg2 = 0 ; + cc::extension::AssetsManagerEx::VersionCompareHandle temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setVersionCompareHandle((cc::extension::AssetsManagerEx::VersionCompareHandle const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setVersionCompareHandle) + +static bool js_cc_extension_AssetsManager_setVerifyCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::VerifyCallback *arg2 = 0 ; + cc::extension::AssetsManagerEx::VerifyCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setVerifyCallback((cc::extension::AssetsManagerEx::VerifyCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setVerifyCallback) + +static bool js_cc_extension_AssetsManager_setEventCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + cc::extension::AssetsManagerEx::EventCallback *arg2 = 0 ; + cc::extension::AssetsManagerEx::EventCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEventCallback((cc::extension::AssetsManagerEx::EventCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_setEventCallback) + +static bool js_cc_extension_AssetsManager_cancelUpdate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::extension::AssetsManagerEx *arg1 = (cc::extension::AssetsManagerEx *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->cancelUpdate(); + + + return true; +} +SE_BIND_FUNC(js_cc_extension_AssetsManager_cancelUpdate) + +bool js_register_cc_extension_AssetsManagerEx(se::Object* obj) { + auto* cls = se::Class::create("AssetsManager", obj, nullptr, _SE(js_new_cc_extension_AssetsManagerEx)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("checkUpdate", _SE(js_cc_extension_AssetsManager_checkUpdate)); + cls->defineFunction("prepareUpdate", _SE(js_cc_extension_AssetsManager_prepareUpdate)); + cls->defineFunction("update", _SE(js_cc_extension_AssetsManager_update)); + cls->defineFunction("downloadFailedAssets", _SE(js_cc_extension_AssetsManager_downloadFailedAssets)); + cls->defineFunction("getState", _SE(js_cc_extension_AssetsManager_getState)); + cls->defineFunction("getStoragePath", _SE(js_cc_extension_AssetsManager_getStoragePath)); + cls->defineFunction("getLocalManifest", _SE(js_cc_extension_AssetsManager_getLocalManifest)); + cls->defineFunction("loadLocalManifest", _SE(js_cc_extension_AssetsManager_loadLocalManifest)); + cls->defineFunction("getRemoteManifest", _SE(js_cc_extension_AssetsManager_getRemoteManifest)); + cls->defineFunction("loadRemoteManifest", _SE(js_cc_extension_AssetsManager_loadRemoteManifest)); + cls->defineFunction("isResuming", _SE(js_cc_extension_AssetsManager_isResuming)); + cls->defineFunction("getTotalBytes", _SE(js_cc_extension_AssetsManager_getTotalBytes)); + cls->defineFunction("getDownloadedBytes", _SE(js_cc_extension_AssetsManager_getDownloadedBytes)); + cls->defineFunction("getTotalFiles", _SE(js_cc_extension_AssetsManager_getTotalFiles)); + cls->defineFunction("getDownloadedFiles", _SE(js_cc_extension_AssetsManager_getDownloadedFiles)); + cls->defineFunction("getMaxConcurrentTask", _SE(js_cc_extension_AssetsManager_getMaxConcurrentTask)); + cls->defineFunction("setMaxConcurrentTask", _SE(js_cc_extension_AssetsManager_setMaxConcurrentTask)); + cls->defineFunction("setVersionCompareHandle", _SE(js_cc_extension_AssetsManager_setVersionCompareHandle)); + cls->defineFunction("setVerifyCallback", _SE(js_cc_extension_AssetsManager_setVerifyCallback)); + cls->defineFunction("setEventCallback", _SE(js_cc_extension_AssetsManager_setEventCallback)); + cls->defineFunction("cancelUpdate", _SE(js_cc_extension_AssetsManager_cancelUpdate)); + + + cls->defineStaticFunction("create", _SE(js_cc_extension_AssetsManager_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_extension_AssetsManagerEx)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_extension_AssetsManagerEx_proto = cls->getProto(); + __jsb_cc_extension_AssetsManagerEx_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_extension(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_extension_EventAssetsManagerEx(ns); + js_register_cc_extension_DownloadUnit(ns); + js_register_cc_extension_ManifestAsset(ns); + js_register_cc_extension_Manifest(ns); + js_register_cc_extension_Manifest_AssetDiff(ns); + js_register_cc_extension_AssetsManagerEx(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_extension_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_extension_auto.h new file mode 100644 index 0000000000..b348bffa0a --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_extension_auto.h @@ -0,0 +1,86 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "extensions/cocos-ext.h" + + + +bool register_all_extension(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::EventAssetsManagerEx); +extern se::Object *__jsb_cc_extension_EventAssetsManagerEx_proto; // NOLINT +extern se::Class * __jsb_cc_extension_EventAssetsManagerEx_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::DownloadUnit); +extern se::Object *__jsb_cc_extension_DownloadUnit_proto; // NOLINT +extern se::Class * __jsb_cc_extension_DownloadUnit_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::DownloadUnit * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::ManifestAsset); +extern se::Object *__jsb_cc_extension_ManifestAsset_proto; // NOLINT +extern se::Class * __jsb_cc_extension_ManifestAsset_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::ManifestAsset * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::Manifest::AssetDiff); +extern se::Object *__jsb_cc_extension_Manifest_AssetDiff_proto; // NOLINT +extern se::Class * __jsb_cc_extension_Manifest_AssetDiff_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::extension::Manifest::AssetDiff * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::Manifest); +extern se::Object *__jsb_cc_extension_Manifest_proto; // NOLINT +extern se::Class * __jsb_cc_extension_Manifest_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::extension::AssetsManagerEx); +extern se::Object *__jsb_cc_extension_AssetsManagerEx_proto; // NOLINT +extern se::Class * __jsb_cc_extension_AssetsManagerEx_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_geometry_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_geometry_auto.cpp new file mode 100644 index 0000000000..e0515cead1 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_geometry_auto.cpp @@ -0,0 +1,3965 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_geometry_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" + + +#define cc_geometry_ShapeBase__type_get(self_) self_->getType() +#define cc_geometry_ShapeBase__type_set(self_, val_) self_->setType(val_) + + + +se::Class* __jsb_cc_geometry_ShapeBase_class = nullptr; +se::Object* __jsb_cc_geometry_ShapeBase_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_ShapeBase) + +static bool js_new_cc_geometry_ShapeBase(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::geometry::ShapeEnum arg1 ; + cc::geometry::ShapeBase *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::ShapeBase *)new cc::geometry::ShapeBase(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_geometry_ShapeBase, __jsb_cc_geometry_ShapeBase_class, js_delete_cc_geometry_ShapeBase) + +static bool js_cc_geometry_ShapeBase__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::ShapeBase *arg1 = (cc::geometry::ShapeBase *) NULL ; + cc::geometry::ShapeEnum arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_geometry_ShapeBase__type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_ShapeBase__type_set) + +static bool js_cc_geometry_ShapeBase__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::ShapeBase *arg1 = (cc::geometry::ShapeBase *) NULL ; + cc::geometry::ShapeEnum result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::ShapeEnum)cc_geometry_ShapeBase__type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_ShapeBase__type_get) + +static bool js_delete_cc_geometry_ShapeBase(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_ShapeBase) + +bool js_register_cc_geometry_ShapeBase(se::Object* obj) { + auto* cls = se::Class::create("ShapeBase", obj, nullptr, _SE(js_new_cc_geometry_ShapeBase)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_type", _SE(js_cc_geometry_ShapeBase__type_get), _SE(js_cc_geometry_ShapeBase__type_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_ShapeBase)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_ShapeBase_proto = cls->getProto(); + __jsb_cc_geometry_ShapeBase_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_AABB_class = nullptr; +se::Object* __jsb_cc_geometry_AABB_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_AABB) + +static bool js_new_cc_geometry_AABB__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::AABB *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::AABB *)new cc::geometry::AABB(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_AABB__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::AABB *result; + result = (cc::geometry::AABB *)new cc::geometry::AABB(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_AABB(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 6) { + ret = js_new_cc_geometry_AABB__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_AABB__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of AABB"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_AABB, __jsb_cc_geometry_AABB_class, js_delete_cc_geometry_AABB) + +static bool js_delete_cc_geometry_AABB(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_AABB) + +static bool js_cc_geometry_AABB_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_AABB_center_set) + +static bool js_cc_geometry_AABB_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_AABB_center_get) + +static bool js_cc_geometry_AABB_halfExtents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->halfExtents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_AABB_halfExtents_set) + +static bool js_cc_geometry_AABB_halfExtents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::AABB *arg1 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->halfExtents, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->halfExtents, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_AABB_halfExtents_get) + +bool js_register_cc_geometry_AABB(se::Object* obj) { + auto* cls = se::Class::create("AABB", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_AABB)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("center", _SE(js_cc_geometry_AABB_center_get), _SE(js_cc_geometry_AABB_center_set)); + cls->defineProperty("halfExtents", _SE(js_cc_geometry_AABB_halfExtents_get), _SE(js_cc_geometry_AABB_halfExtents_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_AABB)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_AABB_proto = cls->getProto(); + __jsb_cc_geometry_AABB_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Line_class = nullptr; +se::Object* __jsb_cc_geometry_Line_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Line) + +static bool js_cc_geometry_Line_s_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->s, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Line_s_set) + +static bool js_cc_geometry_Line_s_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->s, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->s, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Line_s_get) + +static bool js_cc_geometry_Line_e_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->e, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Line_e_set) + +static bool js_cc_geometry_Line_e_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = (cc::geometry::Line *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->e, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->e, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Line_e_get) + +static bool js_new_cc_geometry_Line__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Line *)new cc::geometry::Line(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Line *result; + result = (cc::geometry::Line *)new cc::geometry::Line(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = 0 ; + cc::geometry::Line temp1 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Line *)new cc::geometry::Line((cc::geometry::Line const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Line *arg1 = 0 ; + cc::geometry::Line temp1 ; + cc::geometry::Line *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Line *)new cc::geometry::Line((cc::geometry::Line &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Line(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 6) { + ret = js_new_cc_geometry_Line__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_geometry_Line__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_geometry_Line__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Line__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Line__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Line__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Line__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Line__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Line__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Line"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Line, __jsb_cc_geometry_Line_class, js_delete_cc_geometry_Line) + +static bool js_delete_cc_geometry_Line(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Line) + +bool js_register_cc_geometry_Line(se::Object* obj) { + auto* cls = se::Class::create("Line", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Line)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("s", _SE(js_cc_geometry_Line_s_get), _SE(js_cc_geometry_Line_s_set)); + cls->defineProperty("e", _SE(js_cc_geometry_Line_e_get), _SE(js_cc_geometry_Line_e_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Line)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Line_proto = cls->getProto(); + __jsb_cc_geometry_Line_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Plane_class = nullptr; +se::Object* __jsb_cc_geometry_Plane_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Plane) + +static bool js_new_cc_geometry_Plane__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Plane *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Plane *)new cc::geometry::Plane(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Plane__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Plane *result; + result = (cc::geometry::Plane *)new cc::geometry::Plane(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Plane(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 4) { + ret = js_new_cc_geometry_Plane__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Plane__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Plane"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Plane, __jsb_cc_geometry_Plane_class, js_delete_cc_geometry_Plane) + +static bool js_cc_geometry_Plane_n_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->n, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Plane_n_set) + +static bool js_cc_geometry_Plane_n_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->n, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->n, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Plane_n_get) + +static bool js_cc_geometry_Plane_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->d, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Plane_d_set) + +static bool js_cc_geometry_Plane_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Plane *arg1 = (cc::geometry::Plane *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->d, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Plane_d_get) + +static bool js_delete_cc_geometry_Plane(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Plane) + +bool js_register_cc_geometry_Plane(se::Object* obj) { + auto* cls = se::Class::create("Plane", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Plane)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("n", _SE(js_cc_geometry_Plane_n_get), _SE(js_cc_geometry_Plane_n_set)); + cls->defineProperty("d", _SE(js_cc_geometry_Plane_d_get), _SE(js_cc_geometry_Plane_d_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Plane)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Plane_proto = cls->getProto(); + __jsb_cc_geometry_Plane_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Frustum_class = nullptr; +se::Object* __jsb_cc_geometry_Frustum_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Frustum) + +static bool js_cc_geometry_Frustum_createOrthographic_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + cc::geometry::Frustum::createOrthographic(arg1,arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} + +static bool js_cc_geometry_Frustum_createPerspective_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + cc::geometry::Frustum::createPerspective(arg1,arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Frustum_createPerspective_static) + +static bool js_new_cc_geometry_Frustum__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Frustum *result; + result = (cc::geometry::Frustum *)new cc::geometry::Frustum(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Frustum__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Frustum *arg1 = 0 ; + cc::geometry::Frustum temp1 ; + cc::geometry::Frustum *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Frustum *)new cc::geometry::Frustum((cc::geometry::Frustum const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Frustum(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_geometry_Frustum__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Frustum__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Frustum"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Frustum, __jsb_cc_geometry_Frustum_class, js_delete_cc_geometry_Frustum) + +static bool js_delete_cc_geometry_Frustum(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Frustum) + +static bool js_cc_geometry_Frustum_createOrthographic__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->createOrthographic(arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} + +static bool js_cc_geometry_Frustum_createOrthographic(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_geometry_Frustum_createOrthographic_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_geometry_Frustum_createOrthographic__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Frustum_createOrthographic) + +static bool js_cc_geometry_Frustum_vertices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Frustum_vertices_set) + +static bool js_cc_geometry_Frustum_vertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Frustum_vertices_get) + +static bool js_cc_geometry_Frustum_planes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->planes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Frustum_planes_set) + +static bool js_cc_geometry_Frustum_planes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Frustum *arg1 = (cc::geometry::Frustum *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->planes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->planes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Frustum_planes_get) + +bool js_register_cc_geometry_Frustum(se::Object* obj) { + auto* cls = se::Class::create("Frustum", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Frustum)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertices", _SE(js_cc_geometry_Frustum_vertices_get), _SE(js_cc_geometry_Frustum_vertices_set)); + cls->defineProperty("planes", _SE(js_cc_geometry_Frustum_planes_get), _SE(js_cc_geometry_Frustum_planes_set)); + + cls->defineFunction("createOrthographic", _SE(js_cc_geometry_Frustum_createOrthographic)); + + + cls->defineStaticFunction("createPerspective", _SE(js_cc_geometry_Frustum_createPerspective_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Frustum)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Frustum_proto = cls->getProto(); + __jsb_cc_geometry_Frustum_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Capsule_class = nullptr; +se::Object* __jsb_cc_geometry_Capsule_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Capsule) + +static bool js_cc_geometry_Capsule_radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->radius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_radius_set) + +static bool js_cc_geometry_Capsule_radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->radius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_radius_get) + +static bool js_cc_geometry_Capsule_halfHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->halfHeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_halfHeight_set) + +static bool js_cc_geometry_Capsule_halfHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->halfHeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_halfHeight_get) + +static bool js_cc_geometry_Capsule_axis_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->axis, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_axis_set) + +static bool js_cc_geometry_Capsule_axis_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->axis, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->axis, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_axis_get) + +static bool js_cc_geometry_Capsule_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_center_set) + +static bool js_cc_geometry_Capsule_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_center_get) + +static bool js_cc_geometry_Capsule_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rotation, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_rotation_set) + +static bool js_cc_geometry_Capsule_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rotation, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rotation, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_rotation_get) + +static bool js_cc_geometry_Capsule_ellipseCenter0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ellipseCenter0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_ellipseCenter0_set) + +static bool js_cc_geometry_Capsule_ellipseCenter0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ellipseCenter0, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ellipseCenter0, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_ellipseCenter0_get) + +static bool js_cc_geometry_Capsule_ellipseCenter1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ellipseCenter1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Capsule_ellipseCenter1_set) + +static bool js_cc_geometry_Capsule_ellipseCenter1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = (cc::geometry::Capsule *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ellipseCenter1, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ellipseCenter1, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Capsule_ellipseCenter1_get) + +static bool js_new_cc_geometry_Capsule__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Capsule::CenterEnum arg3 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Capsule *result; + result = (cc::geometry::Capsule *)new cc::geometry::Capsule(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = 0 ; + cc::geometry::Capsule temp1 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Capsule *)new cc::geometry::Capsule((cc::geometry::Capsule const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Capsule *arg1 = 0 ; + cc::geometry::Capsule temp1 ; + cc::geometry::Capsule *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Capsule *)new cc::geometry::Capsule((cc::geometry::Capsule &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Capsule(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_cc_geometry_Capsule__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Capsule__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Capsule__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Capsule__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Capsule__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Capsule__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Capsule"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Capsule, __jsb_cc_geometry_Capsule_class, js_delete_cc_geometry_Capsule) + +static bool js_delete_cc_geometry_Capsule(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Capsule) + +bool js_register_cc_geometry_Capsule(se::Object* obj) { + auto* cls = se::Class::create("Capsule", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Capsule)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("radius", _SE(js_cc_geometry_Capsule_radius_get), _SE(js_cc_geometry_Capsule_radius_set)); + cls->defineProperty("halfHeight", _SE(js_cc_geometry_Capsule_halfHeight_get), _SE(js_cc_geometry_Capsule_halfHeight_set)); + cls->defineProperty("axis", _SE(js_cc_geometry_Capsule_axis_get), _SE(js_cc_geometry_Capsule_axis_set)); + cls->defineProperty("center", _SE(js_cc_geometry_Capsule_center_get), _SE(js_cc_geometry_Capsule_center_set)); + cls->defineProperty("rotation", _SE(js_cc_geometry_Capsule_rotation_get), _SE(js_cc_geometry_Capsule_rotation_set)); + cls->defineProperty("ellipseCenter0", _SE(js_cc_geometry_Capsule_ellipseCenter0_get), _SE(js_cc_geometry_Capsule_ellipseCenter0_set)); + cls->defineProperty("ellipseCenter1", _SE(js_cc_geometry_Capsule_ellipseCenter1_get), _SE(js_cc_geometry_Capsule_ellipseCenter1_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Capsule)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Capsule_proto = cls->getProto(); + __jsb_cc_geometry_Capsule_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Sphere_class = nullptr; +se::Object* __jsb_cc_geometry_Sphere_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Sphere) + +static bool js_new_cc_geometry_Sphere__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Sphere *result; + result = (cc::geometry::Sphere *)new cc::geometry::Sphere(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Sphere *arg1 = 0 ; + cc::geometry::Sphere temp1 ; + cc::geometry::Sphere *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Sphere *)new cc::geometry::Sphere((cc::geometry::Sphere const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Sphere(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 4) { + ret = js_new_cc_geometry_Sphere__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Sphere__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Sphere__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Sphere__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Sphere__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Sphere__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Sphere"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Sphere, __jsb_cc_geometry_Sphere_class, js_delete_cc_geometry_Sphere) + +static bool js_delete_cc_geometry_Sphere(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Sphere) + +static bool js_cc_geometry_Sphere_intersect__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::geometry::Frustum temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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::geometry::Sphere const *)arg1)->intersect((cc::geometry::Frustum const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_geometry_Sphere_intersect__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + cc::geometry::Plane *arg2 = 0 ; + cc::geometry::Plane temp2 ; + int result; + + arg1 = SE_THIS_OBJECT(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 = (int)((cc::geometry::Sphere const *)arg1)->intersect((cc::geometry::Plane const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_geometry_Sphere_intersect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_geometry_Sphere_intersect__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Sphere_intersect__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Sphere_intersect) + +static bool js_cc_geometry_Sphere__radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_radius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Sphere__radius_set) + +static bool js_cc_geometry_Sphere__radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_radius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Sphere__radius_get) + +static bool js_cc_geometry_Sphere__center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Sphere__center_set) + +static bool js_cc_geometry_Sphere__center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Sphere *arg1 = (cc::geometry::Sphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Sphere__center_get) + +bool js_register_cc_geometry_Sphere(se::Object* obj) { + auto* cls = se::Class::create("Sphere", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Sphere)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_radius", _SE(js_cc_geometry_Sphere__radius_get), _SE(js_cc_geometry_Sphere__radius_set)); + cls->defineProperty("_center", _SE(js_cc_geometry_Sphere__center_get), _SE(js_cc_geometry_Sphere__center_set)); + + cls->defineFunction("intersect", _SE(js_cc_geometry_Sphere_intersect)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Sphere)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Sphere_proto = cls->getProto(); + __jsb_cc_geometry_Sphere_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Triangle_class = nullptr; +se::Object* __jsb_cc_geometry_Triangle_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Triangle) + +static bool js_cc_geometry_Triangle_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Triangle_a_set) + +static bool js_cc_geometry_Triangle_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->a, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Triangle_a_get) + +static bool js_cc_geometry_Triangle_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Triangle_b_set) + +static bool js_cc_geometry_Triangle_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->b, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Triangle_b_get) + +static bool js_cc_geometry_Triangle_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->c, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Triangle_c_set) + +static bool js_cc_geometry_Triangle_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = (cc::geometry::Triangle *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->c, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->c, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Triangle_c_get) + +static bool js_new_cc_geometry_Triangle__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_9(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Triangle *result; + result = (cc::geometry::Triangle *)new cc::geometry::Triangle(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_10(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = 0 ; + cc::geometry::Triangle temp1 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Triangle *)new cc::geometry::Triangle((cc::geometry::Triangle const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle__SWIG_11(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Triangle *arg1 = 0 ; + cc::geometry::Triangle temp1 ; + cc::geometry::Triangle *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Triangle *)new cc::geometry::Triangle((cc::geometry::Triangle &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Triangle(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 9) { + ret = js_new_cc_geometry_Triangle__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 8) { + ret = js_new_cc_geometry_Triangle__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 7) { + ret = js_new_cc_geometry_Triangle__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 6) { + ret = js_new_cc_geometry_Triangle__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_geometry_Triangle__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_geometry_Triangle__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Triangle__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Triangle__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Triangle__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Triangle__SWIG_9(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Triangle__SWIG_10(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Triangle__SWIG_11(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Triangle"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Triangle, __jsb_cc_geometry_Triangle_class, js_delete_cc_geometry_Triangle) + +static bool js_delete_cc_geometry_Triangle(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Triangle) + +bool js_register_cc_geometry_Triangle(se::Object* obj) { + auto* cls = se::Class::create("Triangle", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Triangle)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("a", _SE(js_cc_geometry_Triangle_a_get), _SE(js_cc_geometry_Triangle_a_set)); + cls->defineProperty("b", _SE(js_cc_geometry_Triangle_b_get), _SE(js_cc_geometry_Triangle_b_set)); + cls->defineProperty("c", _SE(js_cc_geometry_Triangle_c_get), _SE(js_cc_geometry_Triangle_c_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Triangle)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Triangle_proto = cls->getProto(); + __jsb_cc_geometry_Triangle_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Ray_class = nullptr; +se::Object* __jsb_cc_geometry_Ray_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Ray) + +static bool js_cc_geometry_Ray_o_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->o, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Ray_o_set) + +static bool js_cc_geometry_Ray_o_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->o, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->o, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Ray_o_get) + +static bool js_cc_geometry_Ray_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->d, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_geometry_Ray_d_set) + +static bool js_cc_geometry_Ray_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = (cc::geometry::Ray *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->d, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->d, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_geometry_Ray_d_get) + +static bool js_new_cc_geometry_Ray__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3,arg4,arg5,arg6); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::geometry::Ray *)new cc::geometry::Ray(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Ray *result; + result = (cc::geometry::Ray *)new cc::geometry::Ray(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = 0 ; + cc::geometry::Ray temp1 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Ray *)new cc::geometry::Ray((cc::geometry::Ray const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Ray *arg1 = 0 ; + cc::geometry::Ray temp1 ; + cc::geometry::Ray *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Ray *)new cc::geometry::Ray((cc::geometry::Ray &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Ray(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 6) { + ret = js_new_cc_geometry_Ray__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_cc_geometry_Ray__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_geometry_Ray__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_geometry_Ray__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_geometry_Ray__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Ray__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Ray__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Ray__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Ray__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Ray"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Ray, __jsb_cc_geometry_Ray_class, js_delete_cc_geometry_Ray) + +static bool js_delete_cc_geometry_Ray(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Ray) + +bool js_register_cc_geometry_Ray(se::Object* obj) { + auto* cls = se::Class::create("Ray", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Ray)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("o", _SE(js_cc_geometry_Ray_o_get), _SE(js_cc_geometry_Ray_o_set)); + cls->defineProperty("d", _SE(js_cc_geometry_Ray_d_get), _SE(js_cc_geometry_Ray_d_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Ray)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Ray_proto = cls->getProto(); + __jsb_cc_geometry_Ray_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_geometry_Spline_class = nullptr; +se::Object* __jsb_cc_geometry_Spline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_geometry_Spline) + +static bool js_new_cc_geometry_Spline__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::SplineMode arg1 ; + ccstd::vector< cc::Vec3 > arg2 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Spline *)new cc::geometry::Spline(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::SplineMode arg1 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Spline *)new cc::geometry::Spline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Spline *result; + result = (cc::geometry::Spline *)new cc::geometry::Spline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Spline *arg1 = 0 ; + cc::geometry::Spline temp1 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Spline *)new cc::geometry::Spline((cc::geometry::Spline const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::Spline *arg1 = 0 ; + cc::geometry::Spline temp1 ; + cc::geometry::Spline *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Spline *)new cc::geometry::Spline((cc::geometry::Spline &&)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_geometry_Spline(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 2) { + ret = js_new_cc_geometry_Spline__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Spline__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_geometry_Spline__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Spline__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_geometry_Spline__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Spline"); + return false; +} +SE_BIND_CTOR(js_new_cc_geometry_Spline, __jsb_cc_geometry_Spline_class, js_delete_cc_geometry_Spline) + +static bool js_delete_cc_geometry_Spline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_geometry_Spline) + +static bool js_cc_geometry_Spline_create_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::SplineMode arg1 ; + ccstd::vector< cc::Vec3 > *arg2 = 0 ; + ccstd::vector< cc::Vec3 > temp2 ; + cc::geometry::Spline *result = 0 ; + + + 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::geometry::Spline *)cc::geometry::Spline::create(arg1,(ccstd::vector< cc::Vec3 > 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; +} + +static bool js_cc_geometry_Spline_create_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::SplineMode arg1 ; + cc::geometry::Spline *result = 0 ; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::geometry::Spline *)cc::geometry::Spline::create(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; +} + +static bool js_cc_geometry_Spline_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_geometry_Spline_create_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_create_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_create_static) + +static bool js_cc_geometry_Spline_clone_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = 0 ; + cc::geometry::Spline temp1 ; + cc::geometry::Spline *result = 0 ; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::geometry::Spline *)cc::geometry::Spline::clone((cc::geometry::Spline const &)*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_FUNC(js_cc_geometry_Spline_clone_static) + +static bool js_cc_geometry_Spline_copy_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::geometry::Spline temp2 ; + cc::geometry::Spline *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::geometry::Spline *)cc::geometry::Spline::copy(arg1,(cc::geometry::Spline 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_geometry_Spline_copy_static) + +static bool js_cc_geometry_Spline_setMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::SplineMode arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setMode) + +static bool js_cc_geometry_Spline_getMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::SplineMode result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::SplineMode)((cc::geometry::Spline const *)arg1)->getMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getMode) + +static bool js_cc_geometry_Spline_setKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + ccstd::vector< cc::Vec3 > *arg2 = 0 ; + ccstd::vector< cc::Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setKnots((ccstd::vector< cc::Vec3 > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setKnots) + +static bool js_cc_geometry_Spline_getKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + ccstd::vector< cc::Vec3 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::Vec3 > *) &((cc::geometry::Spline const *)arg1)->getKnots(); + + 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_geometry_Spline_getKnots) + +static bool js_cc_geometry_Spline_clearKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearKnots(); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_clearKnots) + +static bool js_cc_geometry_Spline_getKnotCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::geometry::Spline const *)arg1)->getKnotCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getKnotCount) + +static bool js_cc_geometry_Spline_addKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addKnot((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_addKnot) + +static bool js_cc_geometry_Spline_setModeAndKnots(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + cc::geometry::SplineMode arg2 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< cc::Vec3 > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setModeAndKnots(arg2,(ccstd::vector< cc::Vec3 > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setModeAndKnots) + +static bool js_cc_geometry_Spline_insertKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->insertKnot(arg2,(cc::Vec3 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_insertKnot) + +static bool js_cc_geometry_Spline_removeKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->removeKnot(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_removeKnot) + +static bool js_cc_geometry_Spline_setKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setKnot(arg2,(cc::Vec3 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_geometry_Spline_setKnot) + +static bool js_cc_geometry_Spline_getKnot__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Vec3 *) &((cc::geometry::Spline const *)arg1)->getKnot(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_geometry_Spline_getKnot__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Vec3 *) &(arg1)->getKnot(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_geometry_Spline_getKnot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_geometry_Spline_getKnot__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_getKnot__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getKnot) + +static bool js_cc_geometry_Spline_getPoint__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + float arg2 ; + uint32_t arg3 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + arg1 = SE_THIS_OBJECT(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::geometry::Spline const *)arg1)->getPoint(arg2,arg3); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} + +static bool js_cc_geometry_Spline_getPoint__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + float arg2 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((cc::geometry::Spline const *)arg1)->getPoint(arg2); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} + +static bool js_cc_geometry_Spline_getPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_geometry_Spline_getPoint__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_getPoint__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getPoint) + +static bool js_cc_geometry_Spline_getPoints__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::vector< cc::Vec3 > result; + + arg1 = SE_THIS_OBJECT(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::geometry::Spline const *)arg1)->getPoints(arg2,arg3); + + 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; +} + +static bool js_cc_geometry_Spline_getPoints__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::geometry::Spline *arg1 = (cc::geometry::Spline *) NULL ; + uint32_t arg2 ; + ccstd::vector< cc::Vec3 > result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::geometry::Spline const *)arg1)->getPoints(arg2); + + 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; +} + +static bool js_cc_geometry_Spline_getPoints(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_geometry_Spline_getPoints__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_geometry_Spline_getPoints__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_geometry_Spline_getPoints) + +bool js_register_cc_geometry_Spline(se::Object* obj) { + auto* cls = se::Class::create("Spline", obj, __jsb_cc_geometry_ShapeBase_proto, _SE(js_new_cc_geometry_Spline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setMode", _SE(js_cc_geometry_Spline_setMode)); + cls->defineFunction("getMode", _SE(js_cc_geometry_Spline_getMode)); + cls->defineFunction("setKnots", _SE(js_cc_geometry_Spline_setKnots)); + cls->defineFunction("getKnots", _SE(js_cc_geometry_Spline_getKnots)); + cls->defineFunction("clearKnots", _SE(js_cc_geometry_Spline_clearKnots)); + cls->defineFunction("getKnotCount", _SE(js_cc_geometry_Spline_getKnotCount)); + cls->defineFunction("addKnot", _SE(js_cc_geometry_Spline_addKnot)); + cls->defineFunction("setModeAndKnots", _SE(js_cc_geometry_Spline_setModeAndKnots)); + cls->defineFunction("insertKnot", _SE(js_cc_geometry_Spline_insertKnot)); + cls->defineFunction("removeKnot", _SE(js_cc_geometry_Spline_removeKnot)); + cls->defineFunction("setKnot", _SE(js_cc_geometry_Spline_setKnot)); + cls->defineFunction("getKnot", _SE(js_cc_geometry_Spline_getKnot)); + cls->defineFunction("getPoint", _SE(js_cc_geometry_Spline_getPoint)); + cls->defineFunction("getPoints", _SE(js_cc_geometry_Spline_getPoints)); + + + cls->defineStaticFunction("create", _SE(js_cc_geometry_Spline_create_static)); + cls->defineStaticFunction("clone", _SE(js_cc_geometry_Spline_clone_static)); + cls->defineStaticFunction("copy", _SE(js_cc_geometry_Spline_copy_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_geometry_Spline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_geometry_Spline_proto = cls->getProto(); + __jsb_cc_geometry_Spline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_geometry(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("ns", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("ns", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_geometry_ShapeBase(ns); + js_register_cc_geometry_AABB(ns); + js_register_cc_geometry_Line(ns); + js_register_cc_geometry_Plane(ns); + js_register_cc_geometry_Frustum(ns); + js_register_cc_geometry_Capsule(ns); + js_register_cc_geometry_Sphere(ns); + js_register_cc_geometry_Triangle(ns); + js_register_cc_geometry_Ray(ns); + js_register_cc_geometry_Spline(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_geometry_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_geometry_auto.h new file mode 100644 index 0000000000..81ea1379b3 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_geometry_auto.h @@ -0,0 +1,94 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "core/geometry/Geometry.h" + + + +bool register_all_geometry(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::ShapeBase); +extern se::Object *__jsb_cc_geometry_ShapeBase_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_ShapeBase_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::AABB); +extern se::Object *__jsb_cc_geometry_AABB_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_AABB_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Line); +extern se::Object *__jsb_cc_geometry_Line_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Line_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Plane); +extern se::Object *__jsb_cc_geometry_Plane_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Plane_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Frustum); +extern se::Object *__jsb_cc_geometry_Frustum_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Frustum_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Capsule); +extern se::Object *__jsb_cc_geometry_Capsule_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Capsule_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Sphere); +extern se::Object *__jsb_cc_geometry_Sphere_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Sphere_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Triangle); +extern se::Object *__jsb_cc_geometry_Triangle_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Triangle_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Ray); +extern se::Object *__jsb_cc_geometry_Ray_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Ray_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::geometry::Spline); +extern se::Object *__jsb_cc_geometry_Spline_proto; // NOLINT +extern se::Class * __jsb_cc_geometry_Spline_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_gfx_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gfx_auto.cpp new file mode 100644 index 0000000000..720035e773 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gfx_auto.cpp @@ -0,0 +1,29905 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_gfx_auto.h" + + +#define cc_gfx_Device_gfxAPI_get(self_) self_->getGfxAPI() + + +#define cc_gfx_Device_deviceName_get(self_) self_->getDeviceName() + + +#define cc_gfx_Device_memoryStatus_get(self_) self_->getMemoryStatus() + + +#define cc_gfx_Device_queue_get(self_) self_->getQueue() + + +#define cc_gfx_Device_commandBuffer_get(self_) self_->getCommandBuffer() + + +#define cc_gfx_Device_renderer_get(self_) self_->getRenderer() + + +#define cc_gfx_Device_vendor_get(self_) self_->getVendor() + + +#define cc_gfx_Device_numDrawCalls_get(self_) self_->getNumDrawCalls() + + +#define cc_gfx_Device_numInstances_get(self_) self_->getNumInstances() + + +#define cc_gfx_Device_numTris_get(self_) self_->getNumTris() + + +#define cc_gfx_Device_capabilities_get(self_) self_->getCapabilities() + + +#define cc_gfx_Shader_name_get(self_) self_->getName() + + +#define cc_gfx_Shader_stages_get(self_) self_->getStages() + + +#define cc_gfx_Shader_attributes_get(self_) self_->getAttributes() + + +#define cc_gfx_Shader_blocks_get(self_) self_->getBlocks() + + +#define cc_gfx_Shader_samplers_get(self_) self_->getSamplers() + + +#define cc_gfx_Texture_info_get(self_) self_->getInfo() + + +#define cc_gfx_Texture_viewInfo_get(self_) self_->getViewInfo() + + +#define cc_gfx_Texture_width_get(self_) self_->getWidth() + + +#define cc_gfx_Texture_height_get(self_) self_->getHeight() + + +#define cc_gfx_Texture_format_get(self_) self_->getFormat() + + +#define cc_gfx_Texture_size_get(self_) self_->getSize() + + +#define cc_gfx_Texture_hash_get(self_) self_->getHash() + + +#define cc_gfx_Queue_type_get(self_) self_->getType() + + +#define cc_gfx_RenderPass_hash_get(self_) self_->getHash() + + +#define cc_gfx_DescriptorSet_layout_get(self_) self_->getLayout() + + +#define cc_gfx_DescriptorSetLayout_bindings_get(self_) self_->getBindings() + + +#define cc_gfx_PipelineState_shader_get(self_) self_->getShader() + + +#define cc_gfx_PipelineState_primitive_get(self_) self_->getPrimitive() + + +#define cc_gfx_PipelineState_bindPoint_get(self_) self_->getBindPoint() + + +#define cc_gfx_PipelineState_inputState_get(self_) self_->getInputState() + + +#define cc_gfx_PipelineState_rasterizerState_get(self_) self_->getRasterizerState() + + +#define cc_gfx_PipelineState_depthStencilState_get(self_) self_->getDepthStencilState() + + +#define cc_gfx_PipelineState_blendState_get(self_) self_->getBlendState() + + +#define cc_gfx_PipelineState_renderPass_get(self_) self_->getRenderPass() + + +#define cc_gfx_InputAssembler_vertexBuffers_get(self_) self_->getVertexBuffers() + + +#define cc_gfx_InputAssembler_attributes_get(self_) self_->getAttributes() + + +#define cc_gfx_InputAssembler_indexBuffer_get(self_) self_->getIndexBuffer() + + +#define cc_gfx_InputAssembler_indirectBuffer_get(self_) self_->getIndirectBuffer() + + +#define cc_gfx_InputAssembler_attributesHash_get(self_) self_->getAttributesHash() + + +#define cc_gfx_InputAssembler_drawInfo_get(self_) self_->getDrawInfo() +#define cc_gfx_InputAssembler_drawInfo_set(self_, val_) self_->setDrawInfo(val_) + + +#define cc_gfx_InputAssembler_vertexCount_get(self_) self_->getVertexCount() +#define cc_gfx_InputAssembler_vertexCount_set(self_, val_) self_->setVertexCount(val_) + + +#define cc_gfx_InputAssembler_firstVertex_get(self_) self_->getFirstVertex() +#define cc_gfx_InputAssembler_firstVertex_set(self_, val_) self_->setFirstVertex(val_) + + +#define cc_gfx_InputAssembler_indexCount_get(self_) self_->getIndexCount() +#define cc_gfx_InputAssembler_indexCount_set(self_, val_) self_->setIndexCount(val_) + + +#define cc_gfx_InputAssembler_firstIndex_get(self_) self_->getFirstIndex() +#define cc_gfx_InputAssembler_firstIndex_set(self_, val_) self_->setFirstIndex(val_) + + +#define cc_gfx_InputAssembler_vertexOffset_get(self_) self_->getVertexOffset() +#define cc_gfx_InputAssembler_vertexOffset_set(self_, val_) self_->setVertexOffset(val_) + + +#define cc_gfx_InputAssembler_instanceCount_get(self_) self_->getInstanceCount() +#define cc_gfx_InputAssembler_instanceCount_set(self_, val_) self_->setInstanceCount(val_) + + +#define cc_gfx_InputAssembler_firstInstance_get(self_) self_->getFirstInstance() +#define cc_gfx_InputAssembler_firstInstance_set(self_, val_) self_->setFirstInstance(val_) + + +#define cc_gfx_CommandBuffer_type_get(self_) self_->getType() + + +#define cc_gfx_CommandBuffer_queue_get(self_) self_->getQueue() + + +#define cc_gfx_CommandBuffer_numDrawCalls_get(self_) self_->getNumDrawCalls() + + +#define cc_gfx_CommandBuffer_numInstances_get(self_) self_->getNumInstances() + + +#define cc_gfx_CommandBuffer_numTris_get(self_) self_->getNumTris() + + +#define cc_gfx_Framebuffer_renderPass_get(self_) self_->getRenderPass() + + +#define cc_gfx_Framebuffer_colorTextures_get(self_) self_->getColorTextures() + + +#define cc_gfx_Framebuffer_depthStencilTexture_get(self_) self_->getDepthStencilTexture() + + +#define cc_gfx_Buffer_usage_get(self_) self_->getUsage() + + +#define cc_gfx_Buffer_memUsage_get(self_) self_->getMemUsage() + + +#define cc_gfx_Buffer_stride_get(self_) self_->getStride() + + +#define cc_gfx_Buffer_count_get(self_) self_->getCount() + + +#define cc_gfx_Buffer_size_get(self_) self_->getSize() + + +#define cc_gfx_Buffer_flags_get(self_) self_->getFlags() + + +#define cc_gfx_Sampler_info_get(self_) self_->getInfo() + + +#define cc_gfx_Sampler_hash_get(self_) self_->getHash() + + +#define cc_gfx_Swapchain_width_get(self_) self_->getWidth() + + +#define cc_gfx_Swapchain_height_get(self_) self_->getHeight() + + +#define cc_gfx_Swapchain_surfaceTransform_get(self_) self_->getSurfaceTransform() + + +#define cc_gfx_Swapchain_colorTexture_get(self_) self_->getColorTexture() + + +#define cc_gfx_Swapchain_depthStencilTexture_get(self_) self_->getDepthStencilTexture() + + +#define cc_gfx_GFXObject_objectType_get(self_) self_->getObjectType() + + +#define cc_gfx_GFXObject_objectID_get(self_) self_->getObjectID() + + +#define cc_gfx_GFXObject_typedID_get(self_) self_->getTypedID() + + +#define cc_gfx_GeneralBarrier_hash_get(self_) self_->getHash() + + +#define cc_gfx_GeneralBarrier_info_get(self_) self_->getInfo() + + +#define cc_gfx_TextureBarrier_hash_get(self_) self_->getHash() + + +#define cc_gfx_TextureBarrier_info_get(self_) self_->getInfo() + + + +static bool js_cc_gfx_isCombinedImageSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Type arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::gfx::isCombinedImageSampler(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_isCombinedImageSampler) + +static bool js_cc_gfx_isSampledImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Type arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::gfx::isSampledImage(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_isSampledImage) + +static bool js_cc_gfx_isStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Type arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::gfx::isStorageImage(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_isStorageImage) + +se::Class* __jsb_cc_gfx_Size_class = nullptr; +se::Object* __jsb_cc_gfx_Size_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Size) + +static bool js_cc_gfx_Size_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Size_x_set) + +static bool js_cc_gfx_Size_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Size_x_get) + +static bool js_cc_gfx_Size_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Size_y_set) + +static bool js_cc_gfx_Size_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Size_y_get) + +static bool js_cc_gfx_Size_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Size_z_set) + +static bool js_cc_gfx_Size_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Size_z_get) + +static bool js_cc_gfx_Size_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Size *arg1 = (cc::gfx::Size *) NULL ; + cc::gfx::Size *arg2 = 0 ; + cc::gfx::Size temp2 ; + cc::gfx::Size *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(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::gfx::Size *) &(arg1)->copy((cc::gfx::Size 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_gfx_Size_copy) + +static bool js_new_cc_gfx_Size(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Size *result; + result = (cc::gfx::Size *)new cc::gfx::Size(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Size, __jsb_cc_gfx_Size_class, js_delete_cc_gfx_Size) + +static bool js_delete_cc_gfx_Size(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Size) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Size * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Size(se::Object* obj) { + auto* cls = se::Class::create("Size", obj, nullptr, _SE(js_new_cc_gfx_Size)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Size_x_get), _SE(js_cc_gfx_Size_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Size_y_get), _SE(js_cc_gfx_Size_y_set)); + cls->defineProperty("z", _SE(js_cc_gfx_Size_z_get), _SE(js_cc_gfx_Size_z_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Size_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Size)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Size_proto = cls->getProto(); + __jsb_cc_gfx_Size_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceCaps_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceCaps_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceCaps) + +static bool js_cc_gfx_DeviceCaps_maxVertexAttributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxVertexAttributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxVertexAttributes_set) + +static bool js_cc_gfx_DeviceCaps_maxVertexAttributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxVertexAttributes, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxVertexAttributes_get) + +static bool js_cc_gfx_DeviceCaps_maxVertexUniformVectors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxVertexUniformVectors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_set) + +static bool js_cc_gfx_DeviceCaps_maxVertexUniformVectors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxVertexUniformVectors, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_get) + +static bool js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxFragmentUniformVectors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_set) + +static bool js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxFragmentUniformVectors, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_get) + +static bool js_cc_gfx_DeviceCaps_maxTextureUnits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTextureUnits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxTextureUnits_set) + +static bool js_cc_gfx_DeviceCaps_maxTextureUnits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTextureUnits, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxTextureUnits_get) + +static bool js_cc_gfx_DeviceCaps_maxImageUnits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxImageUnits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxImageUnits_set) + +static bool js_cc_gfx_DeviceCaps_maxImageUnits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxImageUnits, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxImageUnits_get) + +static bool js_cc_gfx_DeviceCaps_maxVertexTextureUnits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxVertexTextureUnits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_set) + +static bool js_cc_gfx_DeviceCaps_maxVertexTextureUnits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxVertexTextureUnits, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_get) + +static bool js_cc_gfx_DeviceCaps_maxColorRenderTargets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxColorRenderTargets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxColorRenderTargets_set) + +static bool js_cc_gfx_DeviceCaps_maxColorRenderTargets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxColorRenderTargets, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxColorRenderTargets_get) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxShaderStorageBufferBindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_set) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxShaderStorageBufferBindings, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_get) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxShaderStorageBlockSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_set) + +static bool js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxShaderStorageBlockSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_get) + +static bool js_cc_gfx_DeviceCaps_maxUniformBufferBindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxUniformBufferBindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_set) + +static bool js_cc_gfx_DeviceCaps_maxUniformBufferBindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxUniformBufferBindings, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_get) + +static bool js_cc_gfx_DeviceCaps_maxUniformBlockSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxUniformBlockSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxUniformBlockSize_set) + +static bool js_cc_gfx_DeviceCaps_maxUniformBlockSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxUniformBlockSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxUniformBlockSize_get) + +static bool js_cc_gfx_DeviceCaps_maxTextureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTextureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxTextureSize_set) + +static bool js_cc_gfx_DeviceCaps_maxTextureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTextureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxTextureSize_get) + +static bool js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxCubeMapTextureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_set) + +static bool js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxCubeMapTextureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_get) + +static bool js_cc_gfx_DeviceCaps_maxArrayTextureLayers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxArrayTextureLayers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_set) + +static bool js_cc_gfx_DeviceCaps_maxArrayTextureLayers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxArrayTextureLayers, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_get) + +static bool js_cc_gfx_DeviceCaps_max3DTextureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->max3DTextureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_max3DTextureSize_set) + +static bool js_cc_gfx_DeviceCaps_max3DTextureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->max3DTextureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_max3DTextureSize_get) + +static bool js_cc_gfx_DeviceCaps_uboOffsetAlignment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uboOffsetAlignment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_uboOffsetAlignment_set) + +static bool js_cc_gfx_DeviceCaps_uboOffsetAlignment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uboOffsetAlignment, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_uboOffsetAlignment_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeSharedMemorySize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeSharedMemorySize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeWorkGroupInvocations, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeWorkGroupInvocations, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeWorkGroupSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeWorkGroupSize, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxComputeWorkGroupSize, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_get) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxComputeWorkGroupCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_set) + +static bool js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxComputeWorkGroupCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxComputeWorkGroupCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_get) + +static bool js_cc_gfx_DeviceCaps_supportQuery_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->supportQuery); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_supportQuery_set) + +static bool js_cc_gfx_DeviceCaps_supportQuery_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->supportQuery, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_supportQuery_get) + +static bool js_cc_gfx_DeviceCaps_supportVariableRateShading_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->supportVariableRateShading); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_supportVariableRateShading_set) + +static bool js_cc_gfx_DeviceCaps_supportVariableRateShading_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->supportVariableRateShading, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_supportVariableRateShading_get) + +static bool js_cc_gfx_DeviceCaps_supportSubPassShading_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->supportSubPassShading); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_supportSubPassShading_set) + +static bool js_cc_gfx_DeviceCaps_supportSubPassShading_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->supportSubPassShading, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_supportSubPassShading_get) + +static bool js_cc_gfx_DeviceCaps_clipSpaceMinZ_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->clipSpaceMinZ, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_clipSpaceMinZ_set) + +static bool js_cc_gfx_DeviceCaps_clipSpaceMinZ_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->clipSpaceMinZ, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_clipSpaceMinZ_get) + +static bool js_cc_gfx_DeviceCaps_screenSpaceSignY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->screenSpaceSignY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_screenSpaceSignY_set) + +static bool js_cc_gfx_DeviceCaps_screenSpaceSignY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->screenSpaceSignY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_screenSpaceSignY_get) + +static bool js_cc_gfx_DeviceCaps_clipSpaceSignY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->clipSpaceSignY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceCaps_clipSpaceSignY_set) + +static bool js_cc_gfx_DeviceCaps_clipSpaceSignY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->clipSpaceSignY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceCaps_clipSpaceSignY_get) + +static bool js_cc_gfx_DeviceCaps_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceCaps *arg1 = (cc::gfx::DeviceCaps *) NULL ; + cc::gfx::DeviceCaps *arg2 = 0 ; + cc::gfx::DeviceCaps temp2 ; + cc::gfx::DeviceCaps *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(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::gfx::DeviceCaps *) &(arg1)->copy((cc::gfx::DeviceCaps 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_gfx_DeviceCaps_copy) + +static bool js_new_cc_gfx_DeviceCaps(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceCaps *result; + result = (cc::gfx::DeviceCaps *)new cc::gfx::DeviceCaps(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceCaps, __jsb_cc_gfx_DeviceCaps_class, js_delete_cc_gfx_DeviceCaps) + +static bool js_delete_cc_gfx_DeviceCaps(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceCaps) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceCaps * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxVertexAttributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxVertexAttributes), ctx); + } + + + json->getProperty("maxVertexUniformVectors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxVertexUniformVectors), ctx); + } + + + json->getProperty("maxFragmentUniformVectors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxFragmentUniformVectors), ctx); + } + + + json->getProperty("maxTextureUnits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTextureUnits), ctx); + } + + + json->getProperty("maxImageUnits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxImageUnits), ctx); + } + + + json->getProperty("maxVertexTextureUnits", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxVertexTextureUnits), ctx); + } + + + json->getProperty("maxColorRenderTargets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxColorRenderTargets), ctx); + } + + + json->getProperty("maxShaderStorageBufferBindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxShaderStorageBufferBindings), ctx); + } + + + json->getProperty("maxShaderStorageBlockSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxShaderStorageBlockSize), ctx); + } + + + json->getProperty("maxUniformBufferBindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxUniformBufferBindings), ctx); + } + + + json->getProperty("maxUniformBlockSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxUniformBlockSize), ctx); + } + + + json->getProperty("maxTextureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTextureSize), ctx); + } + + + json->getProperty("maxCubeMapTextureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxCubeMapTextureSize), ctx); + } + + + json->getProperty("maxArrayTextureLayers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxArrayTextureLayers), ctx); + } + + + json->getProperty("max3DTextureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->max3DTextureSize), ctx); + } + + + json->getProperty("uboOffsetAlignment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uboOffsetAlignment), ctx); + } + + + json->getProperty("maxComputeSharedMemorySize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeSharedMemorySize), ctx); + } + + + json->getProperty("maxComputeWorkGroupInvocations", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeWorkGroupInvocations), ctx); + } + + + json->getProperty("maxComputeWorkGroupSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeWorkGroupSize), ctx); + } + + + json->getProperty("maxComputeWorkGroupCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxComputeWorkGroupCount), ctx); + } + + + json->getProperty("supportQuery", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->supportQuery), ctx); + } + + + json->getProperty("supportVariableRateShading", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->supportVariableRateShading), ctx); + } + + + json->getProperty("supportSubPassShading", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->supportSubPassShading), ctx); + } + + + json->getProperty("clipSpaceMinZ", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->clipSpaceMinZ), ctx); + } + + + json->getProperty("screenSpaceSignY", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->screenSpaceSignY), ctx); + } + + + json->getProperty("clipSpaceSignY", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->clipSpaceSignY), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DeviceCaps(se::Object* obj) { + auto* cls = se::Class::create("DeviceCaps", obj, nullptr, _SE(js_new_cc_gfx_DeviceCaps)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxVertexAttributes", _SE(js_cc_gfx_DeviceCaps_maxVertexAttributes_get), _SE(js_cc_gfx_DeviceCaps_maxVertexAttributes_set)); + cls->defineProperty("maxVertexUniformVectors", _SE(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_get), _SE(js_cc_gfx_DeviceCaps_maxVertexUniformVectors_set)); + cls->defineProperty("maxFragmentUniformVectors", _SE(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_get), _SE(js_cc_gfx_DeviceCaps_maxFragmentUniformVectors_set)); + cls->defineProperty("maxTextureUnits", _SE(js_cc_gfx_DeviceCaps_maxTextureUnits_get), _SE(js_cc_gfx_DeviceCaps_maxTextureUnits_set)); + cls->defineProperty("maxImageUnits", _SE(js_cc_gfx_DeviceCaps_maxImageUnits_get), _SE(js_cc_gfx_DeviceCaps_maxImageUnits_set)); + cls->defineProperty("maxVertexTextureUnits", _SE(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_get), _SE(js_cc_gfx_DeviceCaps_maxVertexTextureUnits_set)); + cls->defineProperty("maxColorRenderTargets", _SE(js_cc_gfx_DeviceCaps_maxColorRenderTargets_get), _SE(js_cc_gfx_DeviceCaps_maxColorRenderTargets_set)); + cls->defineProperty("maxShaderStorageBufferBindings", _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_get), _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBufferBindings_set)); + cls->defineProperty("maxShaderStorageBlockSize", _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_get), _SE(js_cc_gfx_DeviceCaps_maxShaderStorageBlockSize_set)); + cls->defineProperty("maxUniformBufferBindings", _SE(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_get), _SE(js_cc_gfx_DeviceCaps_maxUniformBufferBindings_set)); + cls->defineProperty("maxUniformBlockSize", _SE(js_cc_gfx_DeviceCaps_maxUniformBlockSize_get), _SE(js_cc_gfx_DeviceCaps_maxUniformBlockSize_set)); + cls->defineProperty("maxTextureSize", _SE(js_cc_gfx_DeviceCaps_maxTextureSize_get), _SE(js_cc_gfx_DeviceCaps_maxTextureSize_set)); + cls->defineProperty("maxCubeMapTextureSize", _SE(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_get), _SE(js_cc_gfx_DeviceCaps_maxCubeMapTextureSize_set)); + cls->defineProperty("maxArrayTextureLayers", _SE(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_get), _SE(js_cc_gfx_DeviceCaps_maxArrayTextureLayers_set)); + cls->defineProperty("max3DTextureSize", _SE(js_cc_gfx_DeviceCaps_max3DTextureSize_get), _SE(js_cc_gfx_DeviceCaps_max3DTextureSize_set)); + cls->defineProperty("uboOffsetAlignment", _SE(js_cc_gfx_DeviceCaps_uboOffsetAlignment_get), _SE(js_cc_gfx_DeviceCaps_uboOffsetAlignment_set)); + cls->defineProperty("maxComputeSharedMemorySize", _SE(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_get), _SE(js_cc_gfx_DeviceCaps_maxComputeSharedMemorySize_set)); + cls->defineProperty("maxComputeWorkGroupInvocations", _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_get), _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupInvocations_set)); + cls->defineProperty("maxComputeWorkGroupSize", _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_get), _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupSize_set)); + cls->defineProperty("maxComputeWorkGroupCount", _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_get), _SE(js_cc_gfx_DeviceCaps_maxComputeWorkGroupCount_set)); + cls->defineProperty("supportQuery", _SE(js_cc_gfx_DeviceCaps_supportQuery_get), _SE(js_cc_gfx_DeviceCaps_supportQuery_set)); + cls->defineProperty("supportVariableRateShading", _SE(js_cc_gfx_DeviceCaps_supportVariableRateShading_get), _SE(js_cc_gfx_DeviceCaps_supportVariableRateShading_set)); + cls->defineProperty("supportSubPassShading", _SE(js_cc_gfx_DeviceCaps_supportSubPassShading_get), _SE(js_cc_gfx_DeviceCaps_supportSubPassShading_set)); + cls->defineProperty("clipSpaceMinZ", _SE(js_cc_gfx_DeviceCaps_clipSpaceMinZ_get), _SE(js_cc_gfx_DeviceCaps_clipSpaceMinZ_set)); + cls->defineProperty("screenSpaceSignY", _SE(js_cc_gfx_DeviceCaps_screenSpaceSignY_get), _SE(js_cc_gfx_DeviceCaps_screenSpaceSignY_set)); + cls->defineProperty("clipSpaceSignY", _SE(js_cc_gfx_DeviceCaps_clipSpaceSignY_get), _SE(js_cc_gfx_DeviceCaps_clipSpaceSignY_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DeviceCaps_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceCaps)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceCaps_proto = cls->getProto(); + __jsb_cc_gfx_DeviceCaps_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceOptions_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceOptions_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceOptions) + +static bool js_cc_gfx_DeviceOptions_enableBarrierDeduce_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceOptions *arg1 = (cc::gfx::DeviceOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->enableBarrierDeduce); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceOptions_enableBarrierDeduce_set) + +static bool js_cc_gfx_DeviceOptions_enableBarrierDeduce_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceOptions *arg1 = (cc::gfx::DeviceOptions *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->enableBarrierDeduce, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceOptions_enableBarrierDeduce_get) + +static bool js_new_cc_gfx_DeviceOptions(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceOptions *result; + result = (cc::gfx::DeviceOptions *)new cc::gfx::DeviceOptions(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceOptions, __jsb_cc_gfx_DeviceOptions_class, js_delete_cc_gfx_DeviceOptions) + +static bool js_delete_cc_gfx_DeviceOptions(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceOptions) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceOptions * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("enableBarrierDeduce", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->enableBarrierDeduce), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DeviceOptions(se::Object* obj) { + auto* cls = se::Class::create("DeviceOptions", obj, nullptr, _SE(js_new_cc_gfx_DeviceOptions)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enableBarrierDeduce", _SE(js_cc_gfx_DeviceOptions_enableBarrierDeduce_get), _SE(js_cc_gfx_DeviceOptions_enableBarrierDeduce_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceOptions)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceOptions_proto = cls->getProto(); + __jsb_cc_gfx_DeviceOptions_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Offset_class = nullptr; +se::Object* __jsb_cc_gfx_Offset_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Offset) + +static bool js_cc_gfx_Offset_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Offset_x_set) + +static bool js_cc_gfx_Offset_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Offset_x_get) + +static bool js_cc_gfx_Offset_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Offset_y_set) + +static bool js_cc_gfx_Offset_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Offset_y_get) + +static bool js_cc_gfx_Offset_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Offset_z_set) + +static bool js_cc_gfx_Offset_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Offset_z_get) + +static bool js_cc_gfx_Offset_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Offset *arg1 = (cc::gfx::Offset *) NULL ; + cc::gfx::Offset *arg2 = 0 ; + cc::gfx::Offset temp2 ; + cc::gfx::Offset *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(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::gfx::Offset *) &(arg1)->copy((cc::gfx::Offset 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_gfx_Offset_copy) + +static bool js_new_cc_gfx_Offset(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Offset *result; + result = (cc::gfx::Offset *)new cc::gfx::Offset(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Offset, __jsb_cc_gfx_Offset_class, js_delete_cc_gfx_Offset) + +static bool js_delete_cc_gfx_Offset(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Offset) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Offset * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Offset(se::Object* obj) { + auto* cls = se::Class::create("Offset", obj, nullptr, _SE(js_new_cc_gfx_Offset)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Offset_x_get), _SE(js_cc_gfx_Offset_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Offset_y_get), _SE(js_cc_gfx_Offset_y_set)); + cls->defineProperty("z", _SE(js_cc_gfx_Offset_z_get), _SE(js_cc_gfx_Offset_z_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Offset_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Offset)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Offset_proto = cls->getProto(); + __jsb_cc_gfx_Offset_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Rect_class = nullptr; +se::Object* __jsb_cc_gfx_Rect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Rect) + +static bool js_cc_gfx_Rect_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_x_set) + +static bool js_cc_gfx_Rect_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_x_get) + +static bool js_cc_gfx_Rect_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_y_set) + +static bool js_cc_gfx_Rect_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_y_get) + +static bool js_cc_gfx_Rect_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_width_set) + +static bool js_cc_gfx_Rect_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_width_get) + +static bool js_cc_gfx_Rect_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Rect_height_set) + +static bool js_cc_gfx_Rect_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Rect_height_get) + +static bool js_cc_gfx_Rect_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Rect *arg1 = (cc::gfx::Rect *) NULL ; + cc::gfx::Rect *arg2 = 0 ; + cc::gfx::Rect temp2 ; + cc::gfx::Rect *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(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::gfx::Rect *) &(arg1)->copy((cc::gfx::Rect 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_gfx_Rect_copy) + +static bool js_new_cc_gfx_Rect(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Rect *result; + result = (cc::gfx::Rect *)new cc::gfx::Rect(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Rect, __jsb_cc_gfx_Rect_class, js_delete_cc_gfx_Rect) + +static bool js_delete_cc_gfx_Rect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Rect) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Rect * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Rect(se::Object* obj) { + auto* cls = se::Class::create("Rect", obj, nullptr, _SE(js_new_cc_gfx_Rect)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Rect_x_get), _SE(js_cc_gfx_Rect_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Rect_y_get), _SE(js_cc_gfx_Rect_y_set)); + cls->defineProperty("width", _SE(js_cc_gfx_Rect_width_get), _SE(js_cc_gfx_Rect_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_Rect_height_get), _SE(js_cc_gfx_Rect_height_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Rect_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Rect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Rect_proto = cls->getProto(); + __jsb_cc_gfx_Rect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Extent_class = nullptr; +se::Object* __jsb_cc_gfx_Extent_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Extent) + +static bool js_cc_gfx_Extent_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Extent_width_set) + +static bool js_cc_gfx_Extent_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Extent_width_get) + +static bool js_cc_gfx_Extent_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Extent_height_set) + +static bool js_cc_gfx_Extent_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Extent_height_get) + +static bool js_cc_gfx_Extent_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Extent_depth_set) + +static bool js_cc_gfx_Extent_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Extent_depth_get) + +static bool js_cc_gfx_Extent_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Extent *arg1 = (cc::gfx::Extent *) NULL ; + cc::gfx::Extent *arg2 = 0 ; + cc::gfx::Extent temp2 ; + cc::gfx::Extent *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(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::gfx::Extent *) &(arg1)->copy((cc::gfx::Extent 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_gfx_Extent_copy) + +static bool js_new_cc_gfx_Extent(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Extent *result; + result = (cc::gfx::Extent *)new cc::gfx::Extent(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Extent, __jsb_cc_gfx_Extent_class, js_delete_cc_gfx_Extent) + +static bool js_delete_cc_gfx_Extent(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Extent) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Extent * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Extent(se::Object* obj) { + auto* cls = se::Class::create("Extent", obj, nullptr, _SE(js_new_cc_gfx_Extent)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_gfx_Extent_width_get), _SE(js_cc_gfx_Extent_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_Extent_height_get), _SE(js_cc_gfx_Extent_height_set)); + cls->defineProperty("depth", _SE(js_cc_gfx_Extent_depth_get), _SE(js_cc_gfx_Extent_depth_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Extent_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Extent)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Extent_proto = cls->getProto(); + __jsb_cc_gfx_Extent_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureSubresLayers_class = nullptr; +se::Object* __jsb_cc_gfx_TextureSubresLayers_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresLayers) + +static bool js_cc_gfx_TextureSubresLayers_mipLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresLayers_mipLevel_set) + +static bool js_cc_gfx_TextureSubresLayers_mipLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresLayers_mipLevel_get) + +static bool js_cc_gfx_TextureSubresLayers_baseArrayLayer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseArrayLayer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresLayers_baseArrayLayer_set) + +static bool js_cc_gfx_TextureSubresLayers_baseArrayLayer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseArrayLayer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresLayers_baseArrayLayer_get) + +static bool js_cc_gfx_TextureSubresLayers_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresLayers_layerCount_set) + +static bool js_cc_gfx_TextureSubresLayers_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresLayers_layerCount_get) + +static bool js_cc_gfx_TextureSubresLayers_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresLayers *arg1 = (cc::gfx::TextureSubresLayers *) NULL ; + cc::gfx::TextureSubresLayers *arg2 = 0 ; + cc::gfx::TextureSubresLayers temp2 ; + cc::gfx::TextureSubresLayers *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(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::gfx::TextureSubresLayers *) &(arg1)->copy((cc::gfx::TextureSubresLayers 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_gfx_TextureSubresLayers_copy) + +static bool js_new_cc_gfx_TextureSubresLayers(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureSubresLayers *result; + result = (cc::gfx::TextureSubresLayers *)new cc::gfx::TextureSubresLayers(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureSubresLayers, __jsb_cc_gfx_TextureSubresLayers_class, js_delete_cc_gfx_TextureSubresLayers) + +static bool js_delete_cc_gfx_TextureSubresLayers(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresLayers) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresLayers * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("mipLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipLevel), ctx); + } + + + json->getProperty("baseArrayLayer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseArrayLayer), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureSubresLayers(se::Object* obj) { + auto* cls = se::Class::create("TextureSubresLayers", obj, nullptr, _SE(js_new_cc_gfx_TextureSubresLayers)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("mipLevel", _SE(js_cc_gfx_TextureSubresLayers_mipLevel_get), _SE(js_cc_gfx_TextureSubresLayers_mipLevel_set)); + cls->defineProperty("baseArrayLayer", _SE(js_cc_gfx_TextureSubresLayers_baseArrayLayer_get), _SE(js_cc_gfx_TextureSubresLayers_baseArrayLayer_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureSubresLayers_layerCount_get), _SE(js_cc_gfx_TextureSubresLayers_layerCount_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureSubresLayers_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureSubresLayers)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureSubresLayers_proto = cls->getProto(); + __jsb_cc_gfx_TextureSubresLayers_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureSubresRange_class = nullptr; +se::Object* __jsb_cc_gfx_TextureSubresRange_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresRange) + +static bool js_cc_gfx_TextureSubresRange_baseMipLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseMipLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_baseMipLevel_set) + +static bool js_cc_gfx_TextureSubresRange_baseMipLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseMipLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_baseMipLevel_get) + +static bool js_cc_gfx_TextureSubresRange_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_levelCount_set) + +static bool js_cc_gfx_TextureSubresRange_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_levelCount_get) + +static bool js_cc_gfx_TextureSubresRange_baseArrayLayer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseArrayLayer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_baseArrayLayer_set) + +static bool js_cc_gfx_TextureSubresRange_baseArrayLayer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseArrayLayer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_baseArrayLayer_get) + +static bool js_cc_gfx_TextureSubresRange_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureSubresRange_layerCount_set) + +static bool js_cc_gfx_TextureSubresRange_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureSubresRange_layerCount_get) + +static bool js_cc_gfx_TextureSubresRange_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureSubresRange *arg1 = (cc::gfx::TextureSubresRange *) NULL ; + cc::gfx::TextureSubresRange *arg2 = 0 ; + cc::gfx::TextureSubresRange temp2 ; + cc::gfx::TextureSubresRange *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(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::gfx::TextureSubresRange *) &(arg1)->copy((cc::gfx::TextureSubresRange 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_gfx_TextureSubresRange_copy) + +static bool js_new_cc_gfx_TextureSubresRange(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureSubresRange *result; + result = (cc::gfx::TextureSubresRange *)new cc::gfx::TextureSubresRange(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureSubresRange, __jsb_cc_gfx_TextureSubresRange_class, js_delete_cc_gfx_TextureSubresRange) + +static bool js_delete_cc_gfx_TextureSubresRange(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureSubresRange) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresRange * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("baseMipLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseMipLevel), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("baseArrayLayer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseArrayLayer), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureSubresRange(se::Object* obj) { + auto* cls = se::Class::create("TextureSubresRange", obj, nullptr, _SE(js_new_cc_gfx_TextureSubresRange)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("baseMipLevel", _SE(js_cc_gfx_TextureSubresRange_baseMipLevel_get), _SE(js_cc_gfx_TextureSubresRange_baseMipLevel_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_TextureSubresRange_levelCount_get), _SE(js_cc_gfx_TextureSubresRange_levelCount_set)); + cls->defineProperty("baseArrayLayer", _SE(js_cc_gfx_TextureSubresRange_baseArrayLayer_get), _SE(js_cc_gfx_TextureSubresRange_baseArrayLayer_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureSubresRange_layerCount_get), _SE(js_cc_gfx_TextureSubresRange_layerCount_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureSubresRange_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureSubresRange)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureSubresRange_proto = cls->getProto(); + __jsb_cc_gfx_TextureSubresRange_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureCopy_class = nullptr; +se::Object* __jsb_cc_gfx_TextureCopy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureCopy) + +static bool js_cc_gfx_TextureCopy_srcSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_srcSubres_set) + +static bool js_cc_gfx_TextureCopy_srcSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_srcSubres_get) + +static bool js_cc_gfx_TextureCopy_srcOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_srcOffset_set) + +static bool js_cc_gfx_TextureCopy_srcOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_srcOffset_get) + +static bool js_cc_gfx_TextureCopy_dstSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_dstSubres_set) + +static bool js_cc_gfx_TextureCopy_dstSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_dstSubres_get) + +static bool js_cc_gfx_TextureCopy_dstOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_dstOffset_set) + +static bool js_cc_gfx_TextureCopy_dstOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_dstOffset_get) + +static bool js_cc_gfx_TextureCopy_extent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->extent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureCopy_extent_set) + +static bool js_cc_gfx_TextureCopy_extent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->extent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->extent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureCopy_extent_get) + +static bool js_cc_gfx_TextureCopy_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureCopy *arg1 = (cc::gfx::TextureCopy *) NULL ; + cc::gfx::TextureCopy *arg2 = 0 ; + cc::gfx::TextureCopy temp2 ; + cc::gfx::TextureCopy *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(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::gfx::TextureCopy *) &(arg1)->copy((cc::gfx::TextureCopy 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_gfx_TextureCopy_copy) + +static bool js_new_cc_gfx_TextureCopy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureCopy *result; + result = (cc::gfx::TextureCopy *)new cc::gfx::TextureCopy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureCopy, __jsb_cc_gfx_TextureCopy_class, js_delete_cc_gfx_TextureCopy) + +static bool js_delete_cc_gfx_TextureCopy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureCopy) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureCopy * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcSubres), ctx); + } + + + json->getProperty("srcOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcOffset), ctx); + } + + + json->getProperty("dstSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstSubres), ctx); + } + + + json->getProperty("dstOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstOffset), ctx); + } + + + json->getProperty("extent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->extent), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureCopy(se::Object* obj) { + auto* cls = se::Class::create("TextureCopy", obj, nullptr, _SE(js_new_cc_gfx_TextureCopy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcSubres", _SE(js_cc_gfx_TextureCopy_srcSubres_get), _SE(js_cc_gfx_TextureCopy_srcSubres_set)); + cls->defineProperty("srcOffset", _SE(js_cc_gfx_TextureCopy_srcOffset_get), _SE(js_cc_gfx_TextureCopy_srcOffset_set)); + cls->defineProperty("dstSubres", _SE(js_cc_gfx_TextureCopy_dstSubres_get), _SE(js_cc_gfx_TextureCopy_dstSubres_set)); + cls->defineProperty("dstOffset", _SE(js_cc_gfx_TextureCopy_dstOffset_get), _SE(js_cc_gfx_TextureCopy_dstOffset_set)); + cls->defineProperty("extent", _SE(js_cc_gfx_TextureCopy_extent_get), _SE(js_cc_gfx_TextureCopy_extent_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureCopy_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureCopy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureCopy_proto = cls->getProto(); + __jsb_cc_gfx_TextureCopy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureBlit_class = nullptr; +se::Object* __jsb_cc_gfx_TextureBlit_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureBlit) + +static bool js_cc_gfx_TextureBlit_srcSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_srcSubres_set) + +static bool js_cc_gfx_TextureBlit_srcSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_srcSubres_get) + +static bool js_cc_gfx_TextureBlit_srcOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_srcOffset_set) + +static bool js_cc_gfx_TextureBlit_srcOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_srcOffset_get) + +static bool js_cc_gfx_TextureBlit_srcExtent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcExtent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_srcExtent_set) + +static bool js_cc_gfx_TextureBlit_srcExtent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcExtent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcExtent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_srcExtent_get) + +static bool js_cc_gfx_TextureBlit_dstSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_dstSubres_set) + +static bool js_cc_gfx_TextureBlit_dstSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_dstSubres_get) + +static bool js_cc_gfx_TextureBlit_dstOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_dstOffset_set) + +static bool js_cc_gfx_TextureBlit_dstOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_dstOffset_get) + +static bool js_cc_gfx_TextureBlit_dstExtent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstExtent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBlit_dstExtent_set) + +static bool js_cc_gfx_TextureBlit_dstExtent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstExtent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstExtent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBlit_dstExtent_get) + +static bool js_cc_gfx_TextureBlit_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBlit *arg1 = (cc::gfx::TextureBlit *) NULL ; + cc::gfx::TextureBlit *arg2 = 0 ; + cc::gfx::TextureBlit temp2 ; + cc::gfx::TextureBlit *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(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::gfx::TextureBlit *) &(arg1)->copy((cc::gfx::TextureBlit 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_gfx_TextureBlit_copy) + +static bool js_new_cc_gfx_TextureBlit(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureBlit *result; + result = (cc::gfx::TextureBlit *)new cc::gfx::TextureBlit(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureBlit, __jsb_cc_gfx_TextureBlit_class, js_delete_cc_gfx_TextureBlit) + +static bool js_delete_cc_gfx_TextureBlit(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureBlit) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBlit * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcSubres), ctx); + } + + + json->getProperty("srcOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcOffset), ctx); + } + + + json->getProperty("srcExtent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcExtent), ctx); + } + + + json->getProperty("dstSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstSubres), ctx); + } + + + json->getProperty("dstOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstOffset), ctx); + } + + + json->getProperty("dstExtent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstExtent), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureBlit(se::Object* obj) { + auto* cls = se::Class::create("TextureBlit", obj, nullptr, _SE(js_new_cc_gfx_TextureBlit)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcSubres", _SE(js_cc_gfx_TextureBlit_srcSubres_get), _SE(js_cc_gfx_TextureBlit_srcSubres_set)); + cls->defineProperty("srcOffset", _SE(js_cc_gfx_TextureBlit_srcOffset_get), _SE(js_cc_gfx_TextureBlit_srcOffset_set)); + cls->defineProperty("srcExtent", _SE(js_cc_gfx_TextureBlit_srcExtent_get), _SE(js_cc_gfx_TextureBlit_srcExtent_set)); + cls->defineProperty("dstSubres", _SE(js_cc_gfx_TextureBlit_dstSubres_get), _SE(js_cc_gfx_TextureBlit_dstSubres_set)); + cls->defineProperty("dstOffset", _SE(js_cc_gfx_TextureBlit_dstOffset_get), _SE(js_cc_gfx_TextureBlit_dstOffset_set)); + cls->defineProperty("dstExtent", _SE(js_cc_gfx_TextureBlit_dstExtent_get), _SE(js_cc_gfx_TextureBlit_dstExtent_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureBlit_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureBlit)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureBlit_proto = cls->getProto(); + __jsb_cc_gfx_TextureBlit_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferTextureCopy_class = nullptr; +se::Object* __jsb_cc_gfx_BufferTextureCopy_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferTextureCopy) + +static bool js_cc_gfx_BufferTextureCopy_buffOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_buffOffset_set) + +static bool js_cc_gfx_BufferTextureCopy_buffOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_buffOffset_get) + +static bool js_cc_gfx_BufferTextureCopy_buffStride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffStride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_buffStride_set) + +static bool js_cc_gfx_BufferTextureCopy_buffStride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffStride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_buffStride_get) + +static bool js_cc_gfx_BufferTextureCopy_buffTexHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffTexHeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_buffTexHeight_set) + +static bool js_cc_gfx_BufferTextureCopy_buffTexHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffTexHeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_buffTexHeight_get) + +static bool js_cc_gfx_BufferTextureCopy_texOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_texOffset_set) + +static bool js_cc_gfx_BufferTextureCopy_texOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texOffset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texOffset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_texOffset_get) + +static bool js_cc_gfx_BufferTextureCopy_texExtent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texExtent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_texExtent_set) + +static bool js_cc_gfx_BufferTextureCopy_texExtent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texExtent, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texExtent, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_texExtent_get) + +static bool js_cc_gfx_BufferTextureCopy_texSubres_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texSubres, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferTextureCopy_texSubres_set) + +static bool js_cc_gfx_BufferTextureCopy_texSubres_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texSubres, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texSubres, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferTextureCopy_texSubres_get) + +static bool js_cc_gfx_BufferTextureCopy_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferTextureCopy *arg1 = (cc::gfx::BufferTextureCopy *) NULL ; + cc::gfx::BufferTextureCopy *arg2 = 0 ; + cc::gfx::BufferTextureCopy temp2 ; + cc::gfx::BufferTextureCopy *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(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::gfx::BufferTextureCopy *) &(arg1)->copy((cc::gfx::BufferTextureCopy 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_gfx_BufferTextureCopy_copy) + +static bool js_new_cc_gfx_BufferTextureCopy(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferTextureCopy *result; + result = (cc::gfx::BufferTextureCopy *)new cc::gfx::BufferTextureCopy(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferTextureCopy, __jsb_cc_gfx_BufferTextureCopy_class, js_delete_cc_gfx_BufferTextureCopy) + +static bool js_delete_cc_gfx_BufferTextureCopy(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferTextureCopy) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferTextureCopy * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffOffset), ctx); + } + + + json->getProperty("buffStride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffStride), ctx); + } + + + json->getProperty("buffTexHeight", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffTexHeight), ctx); + } + + + json->getProperty("texOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texOffset), ctx); + } + + + json->getProperty("texExtent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texExtent), ctx); + } + + + json->getProperty("texSubres", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texSubres), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferTextureCopy(se::Object* obj) { + auto* cls = se::Class::create("BufferTextureCopy", obj, nullptr, _SE(js_new_cc_gfx_BufferTextureCopy)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffOffset", _SE(js_cc_gfx_BufferTextureCopy_buffOffset_get), _SE(js_cc_gfx_BufferTextureCopy_buffOffset_set)); + cls->defineProperty("buffStride", _SE(js_cc_gfx_BufferTextureCopy_buffStride_get), _SE(js_cc_gfx_BufferTextureCopy_buffStride_set)); + cls->defineProperty("buffTexHeight", _SE(js_cc_gfx_BufferTextureCopy_buffTexHeight_get), _SE(js_cc_gfx_BufferTextureCopy_buffTexHeight_set)); + cls->defineProperty("texOffset", _SE(js_cc_gfx_BufferTextureCopy_texOffset_get), _SE(js_cc_gfx_BufferTextureCopy_texOffset_set)); + cls->defineProperty("texExtent", _SE(js_cc_gfx_BufferTextureCopy_texExtent_get), _SE(js_cc_gfx_BufferTextureCopy_texExtent_set)); + cls->defineProperty("texSubres", _SE(js_cc_gfx_BufferTextureCopy_texSubres_get), _SE(js_cc_gfx_BufferTextureCopy_texSubres_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferTextureCopy_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferTextureCopy)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferTextureCopy_proto = cls->getProto(); + __jsb_cc_gfx_BufferTextureCopy_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Viewport_class = nullptr; +se::Object* __jsb_cc_gfx_Viewport_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Viewport) + +static bool js_cc_gfx_Viewport_left_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->left, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_left_set) + +static bool js_cc_gfx_Viewport_left_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->left, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_left_get) + +static bool js_cc_gfx_Viewport_top_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->top, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_top_set) + +static bool js_cc_gfx_Viewport_top_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->top, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_top_get) + +static bool js_cc_gfx_Viewport_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_width_set) + +static bool js_cc_gfx_Viewport_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_width_get) + +static bool js_cc_gfx_Viewport_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_height_set) + +static bool js_cc_gfx_Viewport_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_height_get) + +static bool js_cc_gfx_Viewport_minDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minDepth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_minDepth_set) + +static bool js_cc_gfx_Viewport_minDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minDepth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_minDepth_get) + +static bool js_cc_gfx_Viewport_maxDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxDepth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Viewport_maxDepth_set) + +static bool js_cc_gfx_Viewport_maxDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxDepth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Viewport_maxDepth_get) + +static bool js_cc_gfx_Viewport_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + cc::gfx::Viewport *arg2 = 0 ; + cc::gfx::Viewport temp2 ; + cc::gfx::Viewport *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(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::gfx::Viewport *) &(arg1)->copy((cc::gfx::Viewport 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_gfx_Viewport_copy) + +static bool js_cc_gfx_Viewport_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Viewport *arg1 = (cc::gfx::Viewport *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Viewport_reset) + +static bool js_new_cc_gfx_Viewport(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Viewport *result; + result = (cc::gfx::Viewport *)new cc::gfx::Viewport(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Viewport, __jsb_cc_gfx_Viewport_class, js_delete_cc_gfx_Viewport) + +static bool js_delete_cc_gfx_Viewport(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Viewport) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Viewport * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("left", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->left), ctx); + } + + + json->getProperty("top", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->top), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("minDepth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minDepth), ctx); + } + + + json->getProperty("maxDepth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxDepth), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Viewport(se::Object* obj) { + auto* cls = se::Class::create("Viewport", obj, nullptr, _SE(js_new_cc_gfx_Viewport)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("left", _SE(js_cc_gfx_Viewport_left_get), _SE(js_cc_gfx_Viewport_left_set)); + cls->defineProperty("top", _SE(js_cc_gfx_Viewport_top_get), _SE(js_cc_gfx_Viewport_top_set)); + cls->defineProperty("width", _SE(js_cc_gfx_Viewport_width_get), _SE(js_cc_gfx_Viewport_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_Viewport_height_get), _SE(js_cc_gfx_Viewport_height_set)); + cls->defineProperty("minDepth", _SE(js_cc_gfx_Viewport_minDepth_get), _SE(js_cc_gfx_Viewport_minDepth_set)); + cls->defineProperty("maxDepth", _SE(js_cc_gfx_Viewport_maxDepth_get), _SE(js_cc_gfx_Viewport_maxDepth_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Viewport_copy)); + cls->defineFunction("reset", _SE(js_cc_gfx_Viewport_reset)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Viewport)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Viewport_proto = cls->getProto(); + __jsb_cc_gfx_Viewport_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Color_class = nullptr; +se::Object* __jsb_cc_gfx_Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Color) + +static bool js_cc_gfx_Color_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_x_set) + +static bool js_cc_gfx_Color_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_x_get) + +static bool js_cc_gfx_Color_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_y_set) + +static bool js_cc_gfx_Color_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_y_get) + +static bool js_cc_gfx_Color_z_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->z, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_z_set) + +static bool js_cc_gfx_Color_z_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->z, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_z_get) + +static bool js_cc_gfx_Color_w_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->w, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Color_w_set) + +static bool js_cc_gfx_Color_w_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->w, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Color_w_get) + +static bool js_cc_gfx_Color_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Color *arg1 = (cc::gfx::Color *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + cc::gfx::Color *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(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::gfx::Color *) &(arg1)->copy((cc::gfx::Color 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_gfx_Color_copy) + +static bool js_new_cc_gfx_Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Color *result; + result = (cc::gfx::Color *)new cc::gfx::Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Color, __jsb_cc_gfx_Color_class, js_delete_cc_gfx_Color) + +static bool js_delete_cc_gfx_Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Color) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Color * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("x", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->x), ctx); + } + + + json->getProperty("y", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->y), ctx); + } + + + json->getProperty("z", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->z), ctx); + } + + + json->getProperty("w", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->w), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_cc_gfx_Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_cc_gfx_Color_x_get), _SE(js_cc_gfx_Color_x_set)); + cls->defineProperty("y", _SE(js_cc_gfx_Color_y_get), _SE(js_cc_gfx_Color_y_set)); + cls->defineProperty("z", _SE(js_cc_gfx_Color_z_get), _SE(js_cc_gfx_Color_z_set)); + cls->defineProperty("w", _SE(js_cc_gfx_Color_w_get), _SE(js_cc_gfx_Color_w_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Color_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Color_proto = cls->getProto(); + __jsb_cc_gfx_Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_MarkerInfo_class = nullptr; +se::Object* __jsb_cc_gfx_MarkerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_MarkerInfo) + +static bool js_cc_gfx_MarkerInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MarkerInfo_name_set) + +static bool js_cc_gfx_MarkerInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MarkerInfo_name_get) + +static bool js_cc_gfx_MarkerInfo_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->color, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MarkerInfo_color_set) + +static bool js_cc_gfx_MarkerInfo_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MarkerInfo *arg1 = (cc::gfx::MarkerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->color, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->color, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MarkerInfo_color_get) + +static bool js_new_cc_gfx_MarkerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::MarkerInfo *result; + result = (cc::gfx::MarkerInfo *)new cc::gfx::MarkerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_MarkerInfo, __jsb_cc_gfx_MarkerInfo_class, js_delete_cc_gfx_MarkerInfo) + +static bool js_delete_cc_gfx_MarkerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_MarkerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MarkerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("color", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->color), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_MarkerInfo(se::Object* obj) { + auto* cls = se::Class::create("MarkerInfo", obj, nullptr, _SE(js_new_cc_gfx_MarkerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_MarkerInfo_name_get), _SE(js_cc_gfx_MarkerInfo_name_set)); + cls->defineProperty("color", _SE(js_cc_gfx_MarkerInfo_color_get), _SE(js_cc_gfx_MarkerInfo_color_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_MarkerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_MarkerInfo_proto = cls->getProto(); + __jsb_cc_gfx_MarkerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BindingMappingInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BindingMappingInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BindingMappingInfo) + +static bool js_cc_gfx_BindingMappingInfo_maxBlockCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxBlockCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxBlockCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxBlockCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxBlockCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxBlockCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxBlockCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSamplerTextureCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSamplerTextureCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxSamplerTextureCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSamplerCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxSamplerCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSamplerCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxSamplerCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxTextureCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxTextureCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxTextureCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxTextureCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxTextureCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxTextureCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxTextureCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxBufferCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxBufferCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxBufferCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxBufferCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxBufferCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxBufferCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxBufferCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxImageCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxImageCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxImageCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxImageCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxImageCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxImageCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxImageCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxSubpassInputCounts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_set) + +static bool js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxSubpassInputCounts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->maxSubpassInputCounts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_get) + +static bool js_cc_gfx_BindingMappingInfo_setIndices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->setIndices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BindingMappingInfo_setIndices_set) + +static bool js_cc_gfx_BindingMappingInfo_setIndices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->setIndices, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->setIndices, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BindingMappingInfo_setIndices_get) + +static bool js_cc_gfx_BindingMappingInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BindingMappingInfo *arg1 = (cc::gfx::BindingMappingInfo *) NULL ; + cc::gfx::BindingMappingInfo *arg2 = 0 ; + cc::gfx::BindingMappingInfo temp2 ; + cc::gfx::BindingMappingInfo *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(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::gfx::BindingMappingInfo *) &(arg1)->copy((cc::gfx::BindingMappingInfo 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_gfx_BindingMappingInfo_copy) + +static bool js_new_cc_gfx_BindingMappingInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BindingMappingInfo *result; + result = (cc::gfx::BindingMappingInfo *)new cc::gfx::BindingMappingInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BindingMappingInfo, __jsb_cc_gfx_BindingMappingInfo_class, js_delete_cc_gfx_BindingMappingInfo) + +static bool js_delete_cc_gfx_BindingMappingInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BindingMappingInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BindingMappingInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("maxBlockCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxBlockCounts), ctx); + } + + + json->getProperty("maxSamplerTextureCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSamplerTextureCounts), ctx); + } + + + json->getProperty("maxSamplerCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSamplerCounts), ctx); + } + + + json->getProperty("maxTextureCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxTextureCounts), ctx); + } + + + json->getProperty("maxBufferCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxBufferCounts), ctx); + } + + + json->getProperty("maxImageCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxImageCounts), ctx); + } + + + json->getProperty("maxSubpassInputCounts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxSubpassInputCounts), ctx); + } + + + json->getProperty("setIndices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->setIndices), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BindingMappingInfo(se::Object* obj) { + auto* cls = se::Class::create("BindingMappingInfo", obj, nullptr, _SE(js_new_cc_gfx_BindingMappingInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("maxBlockCounts", _SE(js_cc_gfx_BindingMappingInfo_maxBlockCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxBlockCounts_set)); + cls->defineProperty("maxSamplerTextureCounts", _SE(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxSamplerTextureCounts_set)); + cls->defineProperty("maxSamplerCounts", _SE(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxSamplerCounts_set)); + cls->defineProperty("maxTextureCounts", _SE(js_cc_gfx_BindingMappingInfo_maxTextureCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxTextureCounts_set)); + cls->defineProperty("maxBufferCounts", _SE(js_cc_gfx_BindingMappingInfo_maxBufferCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxBufferCounts_set)); + cls->defineProperty("maxImageCounts", _SE(js_cc_gfx_BindingMappingInfo_maxImageCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxImageCounts_set)); + cls->defineProperty("maxSubpassInputCounts", _SE(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_get), _SE(js_cc_gfx_BindingMappingInfo_maxSubpassInputCounts_set)); + cls->defineProperty("setIndices", _SE(js_cc_gfx_BindingMappingInfo_setIndices_get), _SE(js_cc_gfx_BindingMappingInfo_setIndices_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BindingMappingInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BindingMappingInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BindingMappingInfo_proto = cls->getProto(); + __jsb_cc_gfx_BindingMappingInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SwapchainInfo_class = nullptr; +se::Object* __jsb_cc_gfx_SwapchainInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SwapchainInfo) + +static bool js_cc_gfx_SwapchainInfo_windowId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->windowId, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_windowId_set) + +static bool js_cc_gfx_SwapchainInfo_windowId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->windowId, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_windowId_get) + +static bool js_cc_gfx_SwapchainInfo_windowHandle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->windowHandle); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_windowHandle_set) + +static bool js_cc_gfx_SwapchainInfo_windowHandle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->windowHandle, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->windowHandle, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_windowHandle_get) + +static bool js_cc_gfx_SwapchainInfo_vsyncMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vsyncMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_vsyncMode_set) + +static bool js_cc_gfx_SwapchainInfo_vsyncMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vsyncMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vsyncMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_vsyncMode_get) + +static bool js_cc_gfx_SwapchainInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_width_set) + +static bool js_cc_gfx_SwapchainInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_width_get) + +static bool js_cc_gfx_SwapchainInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SwapchainInfo_height_set) + +static bool js_cc_gfx_SwapchainInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SwapchainInfo_height_get) + +static bool js_cc_gfx_SwapchainInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SwapchainInfo *arg1 = (cc::gfx::SwapchainInfo *) NULL ; + cc::gfx::SwapchainInfo *arg2 = 0 ; + cc::gfx::SwapchainInfo temp2 ; + cc::gfx::SwapchainInfo *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(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::gfx::SwapchainInfo *) &(arg1)->copy((cc::gfx::SwapchainInfo 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_gfx_SwapchainInfo_copy) + +static bool js_new_cc_gfx_SwapchainInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SwapchainInfo *result; + result = (cc::gfx::SwapchainInfo *)new cc::gfx::SwapchainInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SwapchainInfo, __jsb_cc_gfx_SwapchainInfo_class, js_delete_cc_gfx_SwapchainInfo) + +static bool js_delete_cc_gfx_SwapchainInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SwapchainInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SwapchainInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("windowId", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->windowId), ctx); + } + + + json->getProperty("windowHandle", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->windowHandle), ctx); + } + + + json->getProperty("vsyncMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vsyncMode), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SwapchainInfo(se::Object* obj) { + auto* cls = se::Class::create("SwapchainInfo", obj, nullptr, _SE(js_new_cc_gfx_SwapchainInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("windowId", _SE(js_cc_gfx_SwapchainInfo_windowId_get), _SE(js_cc_gfx_SwapchainInfo_windowId_set)); + cls->defineProperty("windowHandle", _SE(js_cc_gfx_SwapchainInfo_windowHandle_get), _SE(js_cc_gfx_SwapchainInfo_windowHandle_set)); + cls->defineProperty("vsyncMode", _SE(js_cc_gfx_SwapchainInfo_vsyncMode_get), _SE(js_cc_gfx_SwapchainInfo_vsyncMode_set)); + cls->defineProperty("width", _SE(js_cc_gfx_SwapchainInfo_width_get), _SE(js_cc_gfx_SwapchainInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_SwapchainInfo_height_get), _SE(js_cc_gfx_SwapchainInfo_height_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SwapchainInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SwapchainInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SwapchainInfo_proto = cls->getProto(); + __jsb_cc_gfx_SwapchainInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceInfo) + +static bool js_cc_gfx_DeviceInfo_bindingMappingInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceInfo *arg1 = (cc::gfx::DeviceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindingMappingInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DeviceInfo_bindingMappingInfo_set) + +static bool js_cc_gfx_DeviceInfo_bindingMappingInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DeviceInfo *arg1 = (cc::gfx::DeviceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindingMappingInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindingMappingInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DeviceInfo_bindingMappingInfo_get) + +static bool js_cc_gfx_DeviceInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DeviceInfo *arg1 = (cc::gfx::DeviceInfo *) NULL ; + cc::gfx::DeviceInfo *arg2 = 0 ; + cc::gfx::DeviceInfo temp2 ; + cc::gfx::DeviceInfo *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(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::gfx::DeviceInfo *) &(arg1)->copy((cc::gfx::DeviceInfo 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_gfx_DeviceInfo_copy) + +static bool js_new_cc_gfx_DeviceInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceInfo *result; + result = (cc::gfx::DeviceInfo *)new cc::gfx::DeviceInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceInfo, __jsb_cc_gfx_DeviceInfo_class, js_delete_cc_gfx_DeviceInfo) + +static bool js_delete_cc_gfx_DeviceInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bindingMappingInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindingMappingInfo), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DeviceInfo(se::Object* obj) { + auto* cls = se::Class::create("DeviceInfo", obj, nullptr, _SE(js_new_cc_gfx_DeviceInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindingMappingInfo", _SE(js_cc_gfx_DeviceInfo_bindingMappingInfo_get), _SE(js_cc_gfx_DeviceInfo_bindingMappingInfo_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DeviceInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceInfo_proto = cls->getProto(); + __jsb_cc_gfx_DeviceInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferInfo) + +static bool js_cc_gfx_BufferInfo_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_usage_set) + +static bool js_cc_gfx_BufferInfo_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_usage_get) + +static bool js_cc_gfx_BufferInfo_memUsage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memUsage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_memUsage_set) + +static bool js_cc_gfx_BufferInfo_memUsage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memUsage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memUsage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_memUsage_get) + +static bool js_cc_gfx_BufferInfo_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_size_set) + +static bool js_cc_gfx_BufferInfo_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_size_get) + +static bool js_cc_gfx_BufferInfo_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_stride_set) + +static bool js_cc_gfx_BufferInfo_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_stride_get) + +static bool js_cc_gfx_BufferInfo_flags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferInfo_flags_set) + +static bool js_cc_gfx_BufferInfo_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->flags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferInfo_flags_get) + +static bool js_cc_gfx_BufferInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = (cc::gfx::BufferInfo *) NULL ; + cc::gfx::BufferInfo *arg2 = 0 ; + cc::gfx::BufferInfo temp2 ; + cc::gfx::BufferInfo *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(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::gfx::BufferInfo *) &(arg1)->copy((cc::gfx::BufferInfo 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_gfx_BufferInfo_copy) + +static bool js_new_cc_gfx_BufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferInfo *result; + result = (cc::gfx::BufferInfo *)new cc::gfx::BufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferInfo, __jsb_cc_gfx_BufferInfo_class, js_delete_cc_gfx_BufferInfo) + +static bool js_delete_cc_gfx_BufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + json->getProperty("memUsage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memUsage), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + json->getProperty("flags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flags), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferInfo(se::Object* obj) { + auto* cls = se::Class::create("BufferInfo", obj, nullptr, _SE(js_new_cc_gfx_BufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("usage", _SE(js_cc_gfx_BufferInfo_usage_get), _SE(js_cc_gfx_BufferInfo_usage_set)); + cls->defineProperty("memUsage", _SE(js_cc_gfx_BufferInfo_memUsage_get), _SE(js_cc_gfx_BufferInfo_memUsage_set)); + cls->defineProperty("size", _SE(js_cc_gfx_BufferInfo_size_get), _SE(js_cc_gfx_BufferInfo_size_set)); + cls->defineProperty("stride", _SE(js_cc_gfx_BufferInfo_stride_get), _SE(js_cc_gfx_BufferInfo_stride_set)); + cls->defineProperty("flags", _SE(js_cc_gfx_BufferInfo_flags_get), _SE(js_cc_gfx_BufferInfo_flags_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferInfo_proto = cls->getProto(); + __jsb_cc_gfx_BufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferViewInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BufferViewInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferViewInfo) + +static bool js_cc_gfx_BufferViewInfo_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferViewInfo_buffer_set) + +static bool js_cc_gfx_BufferViewInfo_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferViewInfo_buffer_get) + +static bool js_cc_gfx_BufferViewInfo_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferViewInfo_offset_set) + +static bool js_cc_gfx_BufferViewInfo_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferViewInfo_offset_get) + +static bool js_cc_gfx_BufferViewInfo_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->range, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferViewInfo_range_set) + +static bool js_cc_gfx_BufferViewInfo_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->range, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferViewInfo_range_get) + +static bool js_cc_gfx_BufferViewInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferViewInfo *arg1 = (cc::gfx::BufferViewInfo *) NULL ; + cc::gfx::BufferViewInfo *arg2 = 0 ; + cc::gfx::BufferViewInfo temp2 ; + cc::gfx::BufferViewInfo *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(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::gfx::BufferViewInfo *) &(arg1)->copy((cc::gfx::BufferViewInfo 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_gfx_BufferViewInfo_copy) + +static bool js_new_cc_gfx_BufferViewInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferViewInfo *result; + result = (cc::gfx::BufferViewInfo *)new cc::gfx::BufferViewInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferViewInfo, __jsb_cc_gfx_BufferViewInfo_class, js_delete_cc_gfx_BufferViewInfo) + +static bool js_delete_cc_gfx_BufferViewInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferViewInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferViewInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("range", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->range), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferViewInfo(se::Object* obj) { + auto* cls = se::Class::create("BufferViewInfo", obj, nullptr, _SE(js_new_cc_gfx_BufferViewInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffer", _SE(js_cc_gfx_BufferViewInfo_buffer_get), _SE(js_cc_gfx_BufferViewInfo_buffer_set)); + cls->defineProperty("offset", _SE(js_cc_gfx_BufferViewInfo_offset_get), _SE(js_cc_gfx_BufferViewInfo_offset_set)); + cls->defineProperty("range", _SE(js_cc_gfx_BufferViewInfo_range_get), _SE(js_cc_gfx_BufferViewInfo_range_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferViewInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferViewInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferViewInfo_proto = cls->getProto(); + __jsb_cc_gfx_BufferViewInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DrawInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DrawInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DrawInfo) + +static bool js_cc_gfx_DrawInfo_vertexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_vertexCount_set) + +static bool js_cc_gfx_DrawInfo_vertexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_vertexCount_get) + +static bool js_cc_gfx_DrawInfo_firstVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstVertex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_firstVertex_set) + +static bool js_cc_gfx_DrawInfo_firstVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstVertex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_firstVertex_get) + +static bool js_cc_gfx_DrawInfo_indexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_indexCount_set) + +static bool js_cc_gfx_DrawInfo_indexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_indexCount_get) + +static bool js_cc_gfx_DrawInfo_firstIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_firstIndex_set) + +static bool js_cc_gfx_DrawInfo_firstIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_firstIndex_get) + +static bool js_cc_gfx_DrawInfo_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_vertexOffset_set) + +static bool js_cc_gfx_DrawInfo_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_vertexOffset_get) + +static bool js_cc_gfx_DrawInfo_instanceCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->instanceCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_instanceCount_set) + +static bool js_cc_gfx_DrawInfo_instanceCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->instanceCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_instanceCount_get) + +static bool js_cc_gfx_DrawInfo_firstInstance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstInstance, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DrawInfo_firstInstance_set) + +static bool js_cc_gfx_DrawInfo_firstInstance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstInstance, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DrawInfo_firstInstance_get) + +static bool js_cc_gfx_DrawInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DrawInfo *arg1 = (cc::gfx::DrawInfo *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::gfx::DrawInfo temp2 ; + cc::gfx::DrawInfo *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(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::gfx::DrawInfo *) &(arg1)->copy((cc::gfx::DrawInfo 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_gfx_DrawInfo_copy) + +static bool js_new_cc_gfx_DrawInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DrawInfo *result; + result = (cc::gfx::DrawInfo *)new cc::gfx::DrawInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DrawInfo, __jsb_cc_gfx_DrawInfo_class, js_delete_cc_gfx_DrawInfo) + +static bool js_delete_cc_gfx_DrawInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DrawInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DrawInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("vertexCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexCount), ctx); + } + + + json->getProperty("firstVertex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstVertex), ctx); + } + + + json->getProperty("indexCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexCount), ctx); + } + + + json->getProperty("firstIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstIndex), ctx); + } + + + json->getProperty("vertexOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexOffset), ctx); + } + + + json->getProperty("instanceCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->instanceCount), ctx); + } + + + json->getProperty("firstInstance", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstInstance), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DrawInfo(se::Object* obj) { + auto* cls = se::Class::create("DrawInfo", obj, nullptr, _SE(js_new_cc_gfx_DrawInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexCount", _SE(js_cc_gfx_DrawInfo_vertexCount_get), _SE(js_cc_gfx_DrawInfo_vertexCount_set)); + cls->defineProperty("firstVertex", _SE(js_cc_gfx_DrawInfo_firstVertex_get), _SE(js_cc_gfx_DrawInfo_firstVertex_set)); + cls->defineProperty("indexCount", _SE(js_cc_gfx_DrawInfo_indexCount_get), _SE(js_cc_gfx_DrawInfo_indexCount_set)); + cls->defineProperty("firstIndex", _SE(js_cc_gfx_DrawInfo_firstIndex_get), _SE(js_cc_gfx_DrawInfo_firstIndex_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_gfx_DrawInfo_vertexOffset_get), _SE(js_cc_gfx_DrawInfo_vertexOffset_set)); + cls->defineProperty("instanceCount", _SE(js_cc_gfx_DrawInfo_instanceCount_get), _SE(js_cc_gfx_DrawInfo_instanceCount_set)); + cls->defineProperty("firstInstance", _SE(js_cc_gfx_DrawInfo_firstInstance_get), _SE(js_cc_gfx_DrawInfo_firstInstance_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DrawInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DrawInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DrawInfo_proto = cls->getProto(); + __jsb_cc_gfx_DrawInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DispatchInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DispatchInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DispatchInfo) + +static bool js_cc_gfx_DispatchInfo_groupCountX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupCountX, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_groupCountX_set) + +static bool js_cc_gfx_DispatchInfo_groupCountX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupCountX, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_groupCountX_get) + +static bool js_cc_gfx_DispatchInfo_groupCountY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupCountY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_groupCountY_set) + +static bool js_cc_gfx_DispatchInfo_groupCountY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupCountY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_groupCountY_get) + +static bool js_cc_gfx_DispatchInfo_groupCountZ_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->groupCountZ, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_groupCountZ_set) + +static bool js_cc_gfx_DispatchInfo_groupCountZ_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->groupCountZ, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_groupCountZ_get) + +static bool js_cc_gfx_DispatchInfo_indirectBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indirectBuffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_indirectBuffer_set) + +static bool js_cc_gfx_DispatchInfo_indirectBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indirectBuffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indirectBuffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_indirectBuffer_get) + +static bool js_cc_gfx_DispatchInfo_indirectOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indirectOffset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DispatchInfo_indirectOffset_set) + +static bool js_cc_gfx_DispatchInfo_indirectOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indirectOffset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DispatchInfo_indirectOffset_get) + +static bool js_cc_gfx_DispatchInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DispatchInfo *arg1 = (cc::gfx::DispatchInfo *) NULL ; + cc::gfx::DispatchInfo *arg2 = 0 ; + cc::gfx::DispatchInfo temp2 ; + cc::gfx::DispatchInfo *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(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::gfx::DispatchInfo *) &(arg1)->copy((cc::gfx::DispatchInfo 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_gfx_DispatchInfo_copy) + +static bool js_new_cc_gfx_DispatchInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DispatchInfo *result; + result = (cc::gfx::DispatchInfo *)new cc::gfx::DispatchInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DispatchInfo, __jsb_cc_gfx_DispatchInfo_class, js_delete_cc_gfx_DispatchInfo) + +static bool js_delete_cc_gfx_DispatchInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DispatchInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DispatchInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("groupCountX", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupCountX), ctx); + } + + + json->getProperty("groupCountY", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupCountY), ctx); + } + + + json->getProperty("groupCountZ", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->groupCountZ), ctx); + } + + + json->getProperty("indirectBuffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indirectBuffer), ctx); + } + + + json->getProperty("indirectOffset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indirectOffset), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DispatchInfo(se::Object* obj) { + auto* cls = se::Class::create("DispatchInfo", obj, nullptr, _SE(js_new_cc_gfx_DispatchInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("groupCountX", _SE(js_cc_gfx_DispatchInfo_groupCountX_get), _SE(js_cc_gfx_DispatchInfo_groupCountX_set)); + cls->defineProperty("groupCountY", _SE(js_cc_gfx_DispatchInfo_groupCountY_get), _SE(js_cc_gfx_DispatchInfo_groupCountY_set)); + cls->defineProperty("groupCountZ", _SE(js_cc_gfx_DispatchInfo_groupCountZ_get), _SE(js_cc_gfx_DispatchInfo_groupCountZ_set)); + cls->defineProperty("indirectBuffer", _SE(js_cc_gfx_DispatchInfo_indirectBuffer_get), _SE(js_cc_gfx_DispatchInfo_indirectBuffer_set)); + cls->defineProperty("indirectOffset", _SE(js_cc_gfx_DispatchInfo_indirectOffset_get), _SE(js_cc_gfx_DispatchInfo_indirectOffset_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DispatchInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DispatchInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DispatchInfo_proto = cls->getProto(); + __jsb_cc_gfx_DispatchInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_IndirectBuffer_class = nullptr; +se::Object* __jsb_cc_gfx_IndirectBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_IndirectBuffer) + +static bool js_cc_gfx_IndirectBuffer_drawInfos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::IndirectBuffer *arg1 = (cc::gfx::IndirectBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->drawInfos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_IndirectBuffer_drawInfos_set) + +static bool js_cc_gfx_IndirectBuffer_drawInfos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::IndirectBuffer *arg1 = (cc::gfx::IndirectBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->drawInfos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->drawInfos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_IndirectBuffer_drawInfos_get) + +static bool js_cc_gfx_IndirectBuffer_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::IndirectBuffer *arg1 = (cc::gfx::IndirectBuffer *) NULL ; + cc::gfx::IndirectBuffer *arg2 = 0 ; + cc::gfx::IndirectBuffer temp2 ; + cc::gfx::IndirectBuffer *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(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::gfx::IndirectBuffer *) &(arg1)->copy((cc::gfx::IndirectBuffer 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_gfx_IndirectBuffer_copy) + +static bool js_new_cc_gfx_IndirectBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::IndirectBuffer *result; + result = (cc::gfx::IndirectBuffer *)new cc::gfx::IndirectBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_IndirectBuffer, __jsb_cc_gfx_IndirectBuffer_class, js_delete_cc_gfx_IndirectBuffer) + +static bool js_delete_cc_gfx_IndirectBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_IndirectBuffer) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::IndirectBuffer * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("drawInfos", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->drawInfos), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_IndirectBuffer(se::Object* obj) { + auto* cls = se::Class::create("IndirectBuffer", obj, nullptr, _SE(js_new_cc_gfx_IndirectBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("drawInfos", _SE(js_cc_gfx_IndirectBuffer_drawInfos_get), _SE(js_cc_gfx_IndirectBuffer_drawInfos_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_IndirectBuffer_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_IndirectBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_IndirectBuffer_proto = cls->getProto(); + __jsb_cc_gfx_IndirectBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureInfo_class = nullptr; +se::Object* __jsb_cc_gfx_TextureInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureInfo) + +static bool js_cc_gfx_TextureInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_type_set) + +static bool js_cc_gfx_TextureInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_type_get) + +static bool js_cc_gfx_TextureInfo_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_usage_set) + +static bool js_cc_gfx_TextureInfo_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_usage_get) + +static bool js_cc_gfx_TextureInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_format_set) + +static bool js_cc_gfx_TextureInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_format_get) + +static bool js_cc_gfx_TextureInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_width_set) + +static bool js_cc_gfx_TextureInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_width_get) + +static bool js_cc_gfx_TextureInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_height_set) + +static bool js_cc_gfx_TextureInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_height_get) + +static bool js_cc_gfx_TextureInfo_flags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_flags_set) + +static bool js_cc_gfx_TextureInfo_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->flags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_flags_get) + +static bool js_cc_gfx_TextureInfo_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_layerCount_set) + +static bool js_cc_gfx_TextureInfo_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_layerCount_get) + +static bool js_cc_gfx_TextureInfo_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_levelCount_set) + +static bool js_cc_gfx_TextureInfo_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_levelCount_get) + +static bool js_cc_gfx_TextureInfo_samples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samples, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_samples_set) + +static bool js_cc_gfx_TextureInfo_samples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samples, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samples, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_samples_get) + +static bool js_cc_gfx_TextureInfo_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_depth_set) + +static bool js_cc_gfx_TextureInfo_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_depth_get) + +static bool js_cc_gfx_TextureInfo_externalRes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg1->externalRes); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureInfo_externalRes_set) + +static bool js_cc_gfx_TextureInfo_externalRes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalRes, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalRes, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureInfo_externalRes_get) + +static bool js_cc_gfx_TextureInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureInfo *arg1 = (cc::gfx::TextureInfo *) NULL ; + cc::gfx::TextureInfo *arg2 = 0 ; + cc::gfx::TextureInfo temp2 ; + cc::gfx::TextureInfo *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(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::gfx::TextureInfo *) &(arg1)->copy((cc::gfx::TextureInfo 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_gfx_TextureInfo_copy) + +static bool js_new_cc_gfx_TextureInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureInfo *result; + result = (cc::gfx::TextureInfo *)new cc::gfx::TextureInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureInfo, __jsb_cc_gfx_TextureInfo_class, js_delete_cc_gfx_TextureInfo) + +static bool js_delete_cc_gfx_TextureInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("flags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flags), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("samples", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samples), ctx); + } + + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + json->getProperty("externalRes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalRes), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureInfo", obj, nullptr, _SE(js_new_cc_gfx_TextureInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_TextureInfo_type_get), _SE(js_cc_gfx_TextureInfo_type_set)); + cls->defineProperty("usage", _SE(js_cc_gfx_TextureInfo_usage_get), _SE(js_cc_gfx_TextureInfo_usage_set)); + cls->defineProperty("format", _SE(js_cc_gfx_TextureInfo_format_get), _SE(js_cc_gfx_TextureInfo_format_set)); + cls->defineProperty("width", _SE(js_cc_gfx_TextureInfo_width_get), _SE(js_cc_gfx_TextureInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_TextureInfo_height_get), _SE(js_cc_gfx_TextureInfo_height_set)); + cls->defineProperty("flags", _SE(js_cc_gfx_TextureInfo_flags_get), _SE(js_cc_gfx_TextureInfo_flags_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureInfo_layerCount_get), _SE(js_cc_gfx_TextureInfo_layerCount_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_TextureInfo_levelCount_get), _SE(js_cc_gfx_TextureInfo_levelCount_set)); + cls->defineProperty("samples", _SE(js_cc_gfx_TextureInfo_samples_get), _SE(js_cc_gfx_TextureInfo_samples_set)); + cls->defineProperty("depth", _SE(js_cc_gfx_TextureInfo_depth_get), _SE(js_cc_gfx_TextureInfo_depth_set)); + cls->defineProperty("externalRes", _SE(js_cc_gfx_TextureInfo_externalRes_get), _SE(js_cc_gfx_TextureInfo_externalRes_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureInfo_proto = cls->getProto(); + __jsb_cc_gfx_TextureInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureViewInfo_class = nullptr; +se::Object* __jsb_cc_gfx_TextureViewInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureViewInfo) + +static bool js_cc_gfx_TextureViewInfo_texture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_texture_set) + +static bool js_cc_gfx_TextureViewInfo_texture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_texture_get) + +static bool js_cc_gfx_TextureViewInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_type_set) + +static bool js_cc_gfx_TextureViewInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_type_get) + +static bool js_cc_gfx_TextureViewInfo_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_format_set) + +static bool js_cc_gfx_TextureViewInfo_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_format_get) + +static bool js_cc_gfx_TextureViewInfo_baseLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_baseLevel_set) + +static bool js_cc_gfx_TextureViewInfo_baseLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_baseLevel_get) + +static bool js_cc_gfx_TextureViewInfo_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_levelCount_set) + +static bool js_cc_gfx_TextureViewInfo_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_levelCount_get) + +static bool js_cc_gfx_TextureViewInfo_baseLayer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->baseLayer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_baseLayer_set) + +static bool js_cc_gfx_TextureViewInfo_baseLayer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->baseLayer, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_baseLayer_get) + +static bool js_cc_gfx_TextureViewInfo_layerCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layerCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_layerCount_set) + +static bool js_cc_gfx_TextureViewInfo_layerCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layerCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_layerCount_get) + +static bool js_cc_gfx_TextureViewInfo_basePlane_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->basePlane, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_basePlane_set) + +static bool js_cc_gfx_TextureViewInfo_basePlane_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->basePlane, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_basePlane_get) + +static bool js_cc_gfx_TextureViewInfo_planeCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->planeCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureViewInfo_planeCount_set) + +static bool js_cc_gfx_TextureViewInfo_planeCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->planeCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureViewInfo_planeCount_get) + +static bool js_cc_gfx_TextureViewInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureViewInfo *arg1 = (cc::gfx::TextureViewInfo *) NULL ; + cc::gfx::TextureViewInfo *arg2 = 0 ; + cc::gfx::TextureViewInfo temp2 ; + cc::gfx::TextureViewInfo *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(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::gfx::TextureViewInfo *) &(arg1)->copy((cc::gfx::TextureViewInfo 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_gfx_TextureViewInfo_copy) + +static bool js_new_cc_gfx_TextureViewInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureViewInfo *result; + result = (cc::gfx::TextureViewInfo *)new cc::gfx::TextureViewInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureViewInfo, __jsb_cc_gfx_TextureViewInfo_class, js_delete_cc_gfx_TextureViewInfo) + +static bool js_delete_cc_gfx_TextureViewInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureViewInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureViewInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("texture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texture), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("baseLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseLevel), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("baseLayer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->baseLayer), ctx); + } + + + json->getProperty("layerCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layerCount), ctx); + } + + + json->getProperty("basePlane", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->basePlane), ctx); + } + + + json->getProperty("planeCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->planeCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureViewInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureViewInfo", obj, nullptr, _SE(js_new_cc_gfx_TextureViewInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("texture", _SE(js_cc_gfx_TextureViewInfo_texture_get), _SE(js_cc_gfx_TextureViewInfo_texture_set)); + cls->defineProperty("type", _SE(js_cc_gfx_TextureViewInfo_type_get), _SE(js_cc_gfx_TextureViewInfo_type_set)); + cls->defineProperty("format", _SE(js_cc_gfx_TextureViewInfo_format_get), _SE(js_cc_gfx_TextureViewInfo_format_set)); + cls->defineProperty("baseLevel", _SE(js_cc_gfx_TextureViewInfo_baseLevel_get), _SE(js_cc_gfx_TextureViewInfo_baseLevel_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_TextureViewInfo_levelCount_get), _SE(js_cc_gfx_TextureViewInfo_levelCount_set)); + cls->defineProperty("baseLayer", _SE(js_cc_gfx_TextureViewInfo_baseLayer_get), _SE(js_cc_gfx_TextureViewInfo_baseLayer_set)); + cls->defineProperty("layerCount", _SE(js_cc_gfx_TextureViewInfo_layerCount_get), _SE(js_cc_gfx_TextureViewInfo_layerCount_set)); + cls->defineProperty("basePlane", _SE(js_cc_gfx_TextureViewInfo_basePlane_get), _SE(js_cc_gfx_TextureViewInfo_basePlane_set)); + cls->defineProperty("planeCount", _SE(js_cc_gfx_TextureViewInfo_planeCount_get), _SE(js_cc_gfx_TextureViewInfo_planeCount_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureViewInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureViewInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureViewInfo_proto = cls->getProto(); + __jsb_cc_gfx_TextureViewInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SamplerInfo_class = nullptr; +se::Object* __jsb_cc_gfx_SamplerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SamplerInfo) + +static bool js_cc_gfx_SamplerInfo_minFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_minFilter_set) + +static bool js_cc_gfx_SamplerInfo_minFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_minFilter_get) + +static bool js_cc_gfx_SamplerInfo_magFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->magFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_magFilter_set) + +static bool js_cc_gfx_SamplerInfo_magFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->magFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->magFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_magFilter_get) + +static bool js_cc_gfx_SamplerInfo_mipFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_mipFilter_set) + +static bool js_cc_gfx_SamplerInfo_mipFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->mipFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_mipFilter_get) + +static bool js_cc_gfx_SamplerInfo_addressU_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->addressU, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_addressU_set) + +static bool js_cc_gfx_SamplerInfo_addressU_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->addressU, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->addressU, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_addressU_get) + +static bool js_cc_gfx_SamplerInfo_addressV_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->addressV, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_addressV_set) + +static bool js_cc_gfx_SamplerInfo_addressV_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->addressV, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->addressV, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_addressV_get) + +static bool js_cc_gfx_SamplerInfo_addressW_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->addressW, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_addressW_set) + +static bool js_cc_gfx_SamplerInfo_addressW_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->addressW, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->addressW, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_addressW_get) + +static bool js_cc_gfx_SamplerInfo_maxAnisotropy_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxAnisotropy, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_maxAnisotropy_set) + +static bool js_cc_gfx_SamplerInfo_maxAnisotropy_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxAnisotropy, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_maxAnisotropy_get) + +static bool js_cc_gfx_SamplerInfo_cmpFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cmpFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SamplerInfo_cmpFunc_set) + +static bool js_cc_gfx_SamplerInfo_cmpFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cmpFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cmpFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SamplerInfo_cmpFunc_get) + +static bool js_cc_gfx_SamplerInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = (cc::gfx::SamplerInfo *) NULL ; + cc::gfx::SamplerInfo *arg2 = 0 ; + cc::gfx::SamplerInfo temp2 ; + cc::gfx::SamplerInfo *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(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::gfx::SamplerInfo *) &(arg1)->copy((cc::gfx::SamplerInfo 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_gfx_SamplerInfo_copy) + +static bool js_new_cc_gfx_SamplerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SamplerInfo *result; + result = (cc::gfx::SamplerInfo *)new cc::gfx::SamplerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SamplerInfo, __jsb_cc_gfx_SamplerInfo_class, js_delete_cc_gfx_SamplerInfo) + +static bool js_delete_cc_gfx_SamplerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SamplerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SamplerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("minFilter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->minFilter), ctx); + } + + + json->getProperty("magFilter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->magFilter), ctx); + } + + + json->getProperty("mipFilter", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipFilter), ctx); + } + + + json->getProperty("addressU", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->addressU), ctx); + } + + + json->getProperty("addressV", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->addressV), ctx); + } + + + json->getProperty("addressW", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->addressW), ctx); + } + + + json->getProperty("maxAnisotropy", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxAnisotropy), ctx); + } + + + json->getProperty("cmpFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cmpFunc), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SamplerInfo(se::Object* obj) { + auto* cls = se::Class::create("SamplerInfo", obj, nullptr, _SE(js_new_cc_gfx_SamplerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("minFilter", _SE(js_cc_gfx_SamplerInfo_minFilter_get), _SE(js_cc_gfx_SamplerInfo_minFilter_set)); + cls->defineProperty("magFilter", _SE(js_cc_gfx_SamplerInfo_magFilter_get), _SE(js_cc_gfx_SamplerInfo_magFilter_set)); + cls->defineProperty("mipFilter", _SE(js_cc_gfx_SamplerInfo_mipFilter_get), _SE(js_cc_gfx_SamplerInfo_mipFilter_set)); + cls->defineProperty("addressU", _SE(js_cc_gfx_SamplerInfo_addressU_get), _SE(js_cc_gfx_SamplerInfo_addressU_set)); + cls->defineProperty("addressV", _SE(js_cc_gfx_SamplerInfo_addressV_get), _SE(js_cc_gfx_SamplerInfo_addressV_set)); + cls->defineProperty("addressW", _SE(js_cc_gfx_SamplerInfo_addressW_get), _SE(js_cc_gfx_SamplerInfo_addressW_set)); + cls->defineProperty("maxAnisotropy", _SE(js_cc_gfx_SamplerInfo_maxAnisotropy_get), _SE(js_cc_gfx_SamplerInfo_maxAnisotropy_set)); + cls->defineProperty("cmpFunc", _SE(js_cc_gfx_SamplerInfo_cmpFunc_get), _SE(js_cc_gfx_SamplerInfo_cmpFunc_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SamplerInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SamplerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SamplerInfo_proto = cls->getProto(); + __jsb_cc_gfx_SamplerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Uniform_class = nullptr; +se::Object* __jsb_cc_gfx_Uniform_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Uniform) + +static bool js_cc_gfx_Uniform_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Uniform_name_set) + +static bool js_cc_gfx_Uniform_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Uniform_name_get) + +static bool js_cc_gfx_Uniform_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Uniform_type_set) + +static bool js_cc_gfx_Uniform_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Uniform_type_get) + +static bool js_cc_gfx_Uniform_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Uniform_count_set) + +static bool js_cc_gfx_Uniform_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Uniform_count_get) + +static bool js_cc_gfx_Uniform_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Uniform *arg1 = (cc::gfx::Uniform *) NULL ; + cc::gfx::Uniform *arg2 = 0 ; + cc::gfx::Uniform temp2 ; + cc::gfx::Uniform *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(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::gfx::Uniform *) &(arg1)->copy((cc::gfx::Uniform 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_gfx_Uniform_copy) + +static bool js_new_cc_gfx_Uniform(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Uniform *result; + result = (cc::gfx::Uniform *)new cc::gfx::Uniform(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Uniform, __jsb_cc_gfx_Uniform_class, js_delete_cc_gfx_Uniform) + +static bool js_delete_cc_gfx_Uniform(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Uniform) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Uniform * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Uniform(se::Object* obj) { + auto* cls = se::Class::create("Uniform", obj, nullptr, _SE(js_new_cc_gfx_Uniform)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_Uniform_name_get), _SE(js_cc_gfx_Uniform_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_Uniform_type_get), _SE(js_cc_gfx_Uniform_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_Uniform_count_get), _SE(js_cc_gfx_Uniform_count_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Uniform_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Uniform)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Uniform_proto = cls->getProto(); + __jsb_cc_gfx_Uniform_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformBlock_class = nullptr; +se::Object* __jsb_cc_gfx_UniformBlock_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformBlock) + +static bool js_cc_gfx_UniformBlock_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_set_set) + +static bool js_cc_gfx_UniformBlock_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_set_get) + +static bool js_cc_gfx_UniformBlock_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_binding_set) + +static bool js_cc_gfx_UniformBlock_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_binding_get) + +static bool js_cc_gfx_UniformBlock_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_name_set) + +static bool js_cc_gfx_UniformBlock_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_name_get) + +static bool js_cc_gfx_UniformBlock_members_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->members, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_members_set) + +static bool js_cc_gfx_UniformBlock_members_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->members, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->members, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_members_get) + +static bool js_cc_gfx_UniformBlock_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_count_set) + +static bool js_cc_gfx_UniformBlock_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_count_get) + +static bool js_cc_gfx_UniformBlock_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformBlock_flattened_set) + +static bool js_cc_gfx_UniformBlock_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformBlock_flattened_get) + +static bool js_cc_gfx_UniformBlock_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformBlock *arg1 = (cc::gfx::UniformBlock *) NULL ; + cc::gfx::UniformBlock *arg2 = 0 ; + cc::gfx::UniformBlock temp2 ; + cc::gfx::UniformBlock *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(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::gfx::UniformBlock *) &(arg1)->copy((cc::gfx::UniformBlock 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_gfx_UniformBlock_copy) + +static bool js_new_cc_gfx_UniformBlock(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformBlock *result; + result = (cc::gfx::UniformBlock *)new cc::gfx::UniformBlock(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformBlock, __jsb_cc_gfx_UniformBlock_class, js_delete_cc_gfx_UniformBlock) + +static bool js_delete_cc_gfx_UniformBlock(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformBlock) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformBlock * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("members", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->members), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformBlock(se::Object* obj) { + auto* cls = se::Class::create("UniformBlock", obj, nullptr, _SE(js_new_cc_gfx_UniformBlock)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformBlock_set_get), _SE(js_cc_gfx_UniformBlock_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformBlock_binding_get), _SE(js_cc_gfx_UniformBlock_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformBlock_name_get), _SE(js_cc_gfx_UniformBlock_name_set)); + cls->defineProperty("members", _SE(js_cc_gfx_UniformBlock_members_get), _SE(js_cc_gfx_UniformBlock_members_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformBlock_count_get), _SE(js_cc_gfx_UniformBlock_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformBlock_flattened_get), _SE(js_cc_gfx_UniformBlock_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformBlock_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformBlock)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformBlock_proto = cls->getProto(); + __jsb_cc_gfx_UniformBlock_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformSamplerTexture_class = nullptr; +se::Object* __jsb_cc_gfx_UniformSamplerTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformSamplerTexture) + +static bool js_cc_gfx_UniformSamplerTexture_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_set_set) + +static bool js_cc_gfx_UniformSamplerTexture_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_set_get) + +static bool js_cc_gfx_UniformSamplerTexture_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_binding_set) + +static bool js_cc_gfx_UniformSamplerTexture_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_binding_get) + +static bool js_cc_gfx_UniformSamplerTexture_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_name_set) + +static bool js_cc_gfx_UniformSamplerTexture_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_name_get) + +static bool js_cc_gfx_UniformSamplerTexture_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_type_set) + +static bool js_cc_gfx_UniformSamplerTexture_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_type_get) + +static bool js_cc_gfx_UniformSamplerTexture_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_count_set) + +static bool js_cc_gfx_UniformSamplerTexture_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_count_get) + +static bool js_cc_gfx_UniformSamplerTexture_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSamplerTexture_flattened_set) + +static bool js_cc_gfx_UniformSamplerTexture_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSamplerTexture_flattened_get) + +static bool js_cc_gfx_UniformSamplerTexture_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSamplerTexture *arg1 = (cc::gfx::UniformSamplerTexture *) NULL ; + cc::gfx::UniformSamplerTexture *arg2 = 0 ; + cc::gfx::UniformSamplerTexture temp2 ; + cc::gfx::UniformSamplerTexture *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(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::gfx::UniformSamplerTexture *) &(arg1)->copy((cc::gfx::UniformSamplerTexture 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_gfx_UniformSamplerTexture_copy) + +static bool js_new_cc_gfx_UniformSamplerTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformSamplerTexture *result; + result = (cc::gfx::UniformSamplerTexture *)new cc::gfx::UniformSamplerTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformSamplerTexture, __jsb_cc_gfx_UniformSamplerTexture_class, js_delete_cc_gfx_UniformSamplerTexture) + +static bool js_delete_cc_gfx_UniformSamplerTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformSamplerTexture) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSamplerTexture * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformSamplerTexture(se::Object* obj) { + auto* cls = se::Class::create("UniformSamplerTexture", obj, nullptr, _SE(js_new_cc_gfx_UniformSamplerTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformSamplerTexture_set_get), _SE(js_cc_gfx_UniformSamplerTexture_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformSamplerTexture_binding_get), _SE(js_cc_gfx_UniformSamplerTexture_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformSamplerTexture_name_get), _SE(js_cc_gfx_UniformSamplerTexture_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_UniformSamplerTexture_type_get), _SE(js_cc_gfx_UniformSamplerTexture_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformSamplerTexture_count_get), _SE(js_cc_gfx_UniformSamplerTexture_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformSamplerTexture_flattened_get), _SE(js_cc_gfx_UniformSamplerTexture_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformSamplerTexture_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformSamplerTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformSamplerTexture_proto = cls->getProto(); + __jsb_cc_gfx_UniformSamplerTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformSampler_class = nullptr; +se::Object* __jsb_cc_gfx_UniformSampler_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformSampler) + +static bool js_cc_gfx_UniformSampler_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_set_set) + +static bool js_cc_gfx_UniformSampler_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_set_get) + +static bool js_cc_gfx_UniformSampler_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_binding_set) + +static bool js_cc_gfx_UniformSampler_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_binding_get) + +static bool js_cc_gfx_UniformSampler_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_name_set) + +static bool js_cc_gfx_UniformSampler_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_name_get) + +static bool js_cc_gfx_UniformSampler_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_count_set) + +static bool js_cc_gfx_UniformSampler_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_count_get) + +static bool js_cc_gfx_UniformSampler_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformSampler_flattened_set) + +static bool js_cc_gfx_UniformSampler_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformSampler_flattened_get) + +static bool js_cc_gfx_UniformSampler_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformSampler *arg1 = (cc::gfx::UniformSampler *) NULL ; + cc::gfx::UniformSampler *arg2 = 0 ; + cc::gfx::UniformSampler temp2 ; + cc::gfx::UniformSampler *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(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::gfx::UniformSampler *) &(arg1)->copy((cc::gfx::UniformSampler 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_gfx_UniformSampler_copy) + +static bool js_new_cc_gfx_UniformSampler(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformSampler *result; + result = (cc::gfx::UniformSampler *)new cc::gfx::UniformSampler(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformSampler, __jsb_cc_gfx_UniformSampler_class, js_delete_cc_gfx_UniformSampler) + +static bool js_delete_cc_gfx_UniformSampler(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformSampler) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSampler * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformSampler(se::Object* obj) { + auto* cls = se::Class::create("UniformSampler", obj, nullptr, _SE(js_new_cc_gfx_UniformSampler)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformSampler_set_get), _SE(js_cc_gfx_UniformSampler_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformSampler_binding_get), _SE(js_cc_gfx_UniformSampler_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformSampler_name_get), _SE(js_cc_gfx_UniformSampler_name_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformSampler_count_get), _SE(js_cc_gfx_UniformSampler_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformSampler_flattened_get), _SE(js_cc_gfx_UniformSampler_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformSampler_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformSampler)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformSampler_proto = cls->getProto(); + __jsb_cc_gfx_UniformSampler_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformTexture_class = nullptr; +se::Object* __jsb_cc_gfx_UniformTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformTexture) + +static bool js_cc_gfx_UniformTexture_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_set_set) + +static bool js_cc_gfx_UniformTexture_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_set_get) + +static bool js_cc_gfx_UniformTexture_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_binding_set) + +static bool js_cc_gfx_UniformTexture_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_binding_get) + +static bool js_cc_gfx_UniformTexture_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_name_set) + +static bool js_cc_gfx_UniformTexture_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_name_get) + +static bool js_cc_gfx_UniformTexture_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_type_set) + +static bool js_cc_gfx_UniformTexture_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_type_get) + +static bool js_cc_gfx_UniformTexture_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_count_set) + +static bool js_cc_gfx_UniformTexture_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_count_get) + +static bool js_cc_gfx_UniformTexture_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformTexture_flattened_set) + +static bool js_cc_gfx_UniformTexture_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformTexture_flattened_get) + +static bool js_cc_gfx_UniformTexture_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformTexture *arg1 = (cc::gfx::UniformTexture *) NULL ; + cc::gfx::UniformTexture *arg2 = 0 ; + cc::gfx::UniformTexture temp2 ; + cc::gfx::UniformTexture *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(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::gfx::UniformTexture *) &(arg1)->copy((cc::gfx::UniformTexture 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_gfx_UniformTexture_copy) + +static bool js_new_cc_gfx_UniformTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformTexture *result; + result = (cc::gfx::UniformTexture *)new cc::gfx::UniformTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformTexture, __jsb_cc_gfx_UniformTexture_class, js_delete_cc_gfx_UniformTexture) + +static bool js_delete_cc_gfx_UniformTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformTexture) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformTexture * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformTexture(se::Object* obj) { + auto* cls = se::Class::create("UniformTexture", obj, nullptr, _SE(js_new_cc_gfx_UniformTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformTexture_set_get), _SE(js_cc_gfx_UniformTexture_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformTexture_binding_get), _SE(js_cc_gfx_UniformTexture_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformTexture_name_get), _SE(js_cc_gfx_UniformTexture_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_UniformTexture_type_get), _SE(js_cc_gfx_UniformTexture_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformTexture_count_get), _SE(js_cc_gfx_UniformTexture_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformTexture_flattened_get), _SE(js_cc_gfx_UniformTexture_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformTexture_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformTexture_proto = cls->getProto(); + __jsb_cc_gfx_UniformTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformStorageImage_class = nullptr; +se::Object* __jsb_cc_gfx_UniformStorageImage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageImage) + +static bool js_cc_gfx_UniformStorageImage_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_set_set) + +static bool js_cc_gfx_UniformStorageImage_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_set_get) + +static bool js_cc_gfx_UniformStorageImage_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_binding_set) + +static bool js_cc_gfx_UniformStorageImage_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_binding_get) + +static bool js_cc_gfx_UniformStorageImage_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_name_set) + +static bool js_cc_gfx_UniformStorageImage_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_name_get) + +static bool js_cc_gfx_UniformStorageImage_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_type_set) + +static bool js_cc_gfx_UniformStorageImage_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_type_get) + +static bool js_cc_gfx_UniformStorageImage_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_count_set) + +static bool js_cc_gfx_UniformStorageImage_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_count_get) + +static bool js_cc_gfx_UniformStorageImage_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_memoryAccess_set) + +static bool js_cc_gfx_UniformStorageImage_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_memoryAccess_get) + +static bool js_cc_gfx_UniformStorageImage_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageImage_flattened_set) + +static bool js_cc_gfx_UniformStorageImage_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageImage_flattened_get) + +static bool js_cc_gfx_UniformStorageImage_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageImage *arg1 = (cc::gfx::UniformStorageImage *) NULL ; + cc::gfx::UniformStorageImage *arg2 = 0 ; + cc::gfx::UniformStorageImage temp2 ; + cc::gfx::UniformStorageImage *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(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::gfx::UniformStorageImage *) &(arg1)->copy((cc::gfx::UniformStorageImage 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_gfx_UniformStorageImage_copy) + +static bool js_new_cc_gfx_UniformStorageImage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformStorageImage *result; + result = (cc::gfx::UniformStorageImage *)new cc::gfx::UniformStorageImage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformStorageImage, __jsb_cc_gfx_UniformStorageImage_class, js_delete_cc_gfx_UniformStorageImage) + +static bool js_delete_cc_gfx_UniformStorageImage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageImage) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageImage * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformStorageImage(se::Object* obj) { + auto* cls = se::Class::create("UniformStorageImage", obj, nullptr, _SE(js_new_cc_gfx_UniformStorageImage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformStorageImage_set_get), _SE(js_cc_gfx_UniformStorageImage_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformStorageImage_binding_get), _SE(js_cc_gfx_UniformStorageImage_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformStorageImage_name_get), _SE(js_cc_gfx_UniformStorageImage_name_set)); + cls->defineProperty("type", _SE(js_cc_gfx_UniformStorageImage_type_get), _SE(js_cc_gfx_UniformStorageImage_type_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformStorageImage_count_get), _SE(js_cc_gfx_UniformStorageImage_count_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_gfx_UniformStorageImage_memoryAccess_get), _SE(js_cc_gfx_UniformStorageImage_memoryAccess_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformStorageImage_flattened_get), _SE(js_cc_gfx_UniformStorageImage_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformStorageImage_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformStorageImage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformStorageImage_proto = cls->getProto(); + __jsb_cc_gfx_UniformStorageImage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformStorageBuffer_class = nullptr; +se::Object* __jsb_cc_gfx_UniformStorageBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageBuffer) + +static bool js_cc_gfx_UniformStorageBuffer_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_set_set) + +static bool js_cc_gfx_UniformStorageBuffer_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_set_get) + +static bool js_cc_gfx_UniformStorageBuffer_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_binding_set) + +static bool js_cc_gfx_UniformStorageBuffer_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_binding_get) + +static bool js_cc_gfx_UniformStorageBuffer_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_name_set) + +static bool js_cc_gfx_UniformStorageBuffer_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_name_get) + +static bool js_cc_gfx_UniformStorageBuffer_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_count_set) + +static bool js_cc_gfx_UniformStorageBuffer_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_count_get) + +static bool js_cc_gfx_UniformStorageBuffer_memoryAccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->memoryAccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_memoryAccess_set) + +static bool js_cc_gfx_UniformStorageBuffer_memoryAccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->memoryAccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->memoryAccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_memoryAccess_get) + +static bool js_cc_gfx_UniformStorageBuffer_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformStorageBuffer_flattened_set) + +static bool js_cc_gfx_UniformStorageBuffer_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformStorageBuffer_flattened_get) + +static bool js_cc_gfx_UniformStorageBuffer_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformStorageBuffer *arg1 = (cc::gfx::UniformStorageBuffer *) NULL ; + cc::gfx::UniformStorageBuffer *arg2 = 0 ; + cc::gfx::UniformStorageBuffer temp2 ; + cc::gfx::UniformStorageBuffer *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(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::gfx::UniformStorageBuffer *) &(arg1)->copy((cc::gfx::UniformStorageBuffer 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_gfx_UniformStorageBuffer_copy) + +static bool js_new_cc_gfx_UniformStorageBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformStorageBuffer *result; + result = (cc::gfx::UniformStorageBuffer *)new cc::gfx::UniformStorageBuffer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformStorageBuffer, __jsb_cc_gfx_UniformStorageBuffer_class, js_delete_cc_gfx_UniformStorageBuffer) + +static bool js_delete_cc_gfx_UniformStorageBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformStorageBuffer) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageBuffer * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("memoryAccess", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->memoryAccess), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformStorageBuffer(se::Object* obj) { + auto* cls = se::Class::create("UniformStorageBuffer", obj, nullptr, _SE(js_new_cc_gfx_UniformStorageBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformStorageBuffer_set_get), _SE(js_cc_gfx_UniformStorageBuffer_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformStorageBuffer_binding_get), _SE(js_cc_gfx_UniformStorageBuffer_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformStorageBuffer_name_get), _SE(js_cc_gfx_UniformStorageBuffer_name_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformStorageBuffer_count_get), _SE(js_cc_gfx_UniformStorageBuffer_count_set)); + cls->defineProperty("memoryAccess", _SE(js_cc_gfx_UniformStorageBuffer_memoryAccess_get), _SE(js_cc_gfx_UniformStorageBuffer_memoryAccess_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformStorageBuffer_flattened_get), _SE(js_cc_gfx_UniformStorageBuffer_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformStorageBuffer_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformStorageBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformStorageBuffer_proto = cls->getProto(); + __jsb_cc_gfx_UniformStorageBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_UniformInputAttachment_class = nullptr; +se::Object* __jsb_cc_gfx_UniformInputAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_UniformInputAttachment) + +static bool js_cc_gfx_UniformInputAttachment_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_set_set) + +static bool js_cc_gfx_UniformInputAttachment_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_set_get) + +static bool js_cc_gfx_UniformInputAttachment_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_binding_set) + +static bool js_cc_gfx_UniformInputAttachment_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_binding_get) + +static bool js_cc_gfx_UniformInputAttachment_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_name_set) + +static bool js_cc_gfx_UniformInputAttachment_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_name_get) + +static bool js_cc_gfx_UniformInputAttachment_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_count_set) + +static bool js_cc_gfx_UniformInputAttachment_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_count_get) + +static bool js_cc_gfx_UniformInputAttachment_flattened_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flattened, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_UniformInputAttachment_flattened_set) + +static bool js_cc_gfx_UniformInputAttachment_flattened_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flattened, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_UniformInputAttachment_flattened_get) + +static bool js_cc_gfx_UniformInputAttachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::UniformInputAttachment *arg1 = (cc::gfx::UniformInputAttachment *) NULL ; + cc::gfx::UniformInputAttachment *arg2 = 0 ; + cc::gfx::UniformInputAttachment temp2 ; + cc::gfx::UniformInputAttachment *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(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::gfx::UniformInputAttachment *) &(arg1)->copy((cc::gfx::UniformInputAttachment 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_gfx_UniformInputAttachment_copy) + +static bool js_new_cc_gfx_UniformInputAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::UniformInputAttachment *result; + result = (cc::gfx::UniformInputAttachment *)new cc::gfx::UniformInputAttachment(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_UniformInputAttachment, __jsb_cc_gfx_UniformInputAttachment_class, js_delete_cc_gfx_UniformInputAttachment) + +static bool js_delete_cc_gfx_UniformInputAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_UniformInputAttachment) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformInputAttachment * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("flattened", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flattened), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_UniformInputAttachment(se::Object* obj) { + auto* cls = se::Class::create("UniformInputAttachment", obj, nullptr, _SE(js_new_cc_gfx_UniformInputAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("set", _SE(js_cc_gfx_UniformInputAttachment_set_get), _SE(js_cc_gfx_UniformInputAttachment_set_set)); + cls->defineProperty("binding", _SE(js_cc_gfx_UniformInputAttachment_binding_get), _SE(js_cc_gfx_UniformInputAttachment_binding_set)); + cls->defineProperty("name", _SE(js_cc_gfx_UniformInputAttachment_name_get), _SE(js_cc_gfx_UniformInputAttachment_name_set)); + cls->defineProperty("count", _SE(js_cc_gfx_UniformInputAttachment_count_get), _SE(js_cc_gfx_UniformInputAttachment_count_set)); + cls->defineProperty("flattened", _SE(js_cc_gfx_UniformInputAttachment_flattened_get), _SE(js_cc_gfx_UniformInputAttachment_flattened_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_UniformInputAttachment_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_UniformInputAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_UniformInputAttachment_proto = cls->getProto(); + __jsb_cc_gfx_UniformInputAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ShaderStage_class = nullptr; +se::Object* __jsb_cc_gfx_ShaderStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ShaderStage) + +static bool js_cc_gfx_ShaderStage_stage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderStage_stage_set) + +static bool js_cc_gfx_ShaderStage_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderStage_stage_get) + +static bool js_cc_gfx_ShaderStage_source_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->source, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderStage_source_set) + +static bool js_cc_gfx_ShaderStage_source_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->source, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->source, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderStage_source_get) + +static bool js_cc_gfx_ShaderStage_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderStage *arg1 = (cc::gfx::ShaderStage *) NULL ; + cc::gfx::ShaderStage *arg2 = 0 ; + cc::gfx::ShaderStage temp2 ; + cc::gfx::ShaderStage *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(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::gfx::ShaderStage *) &(arg1)->copy((cc::gfx::ShaderStage 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_gfx_ShaderStage_copy) + +static bool js_new_cc_gfx_ShaderStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ShaderStage *result; + result = (cc::gfx::ShaderStage *)new cc::gfx::ShaderStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ShaderStage, __jsb_cc_gfx_ShaderStage_class, js_delete_cc_gfx_ShaderStage) + +static bool js_delete_cc_gfx_ShaderStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ShaderStage) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderStage * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("stage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stage), ctx); + } + + + json->getProperty("source", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->source), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ShaderStage(se::Object* obj) { + auto* cls = se::Class::create("ShaderStage", obj, nullptr, _SE(js_new_cc_gfx_ShaderStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("stage", _SE(js_cc_gfx_ShaderStage_stage_get), _SE(js_cc_gfx_ShaderStage_stage_set)); + cls->defineProperty("source", _SE(js_cc_gfx_ShaderStage_source_get), _SE(js_cc_gfx_ShaderStage_source_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_ShaderStage_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ShaderStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ShaderStage_proto = cls->getProto(); + __jsb_cc_gfx_ShaderStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Attribute_class = nullptr; +se::Object* __jsb_cc_gfx_Attribute_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Attribute) + +static bool js_cc_gfx_Attribute_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_name_set) + +static bool js_cc_gfx_Attribute_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_name_get) + +static bool js_cc_gfx_Attribute_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_format_set) + +static bool js_cc_gfx_Attribute_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_format_get) + +static bool js_cc_gfx_Attribute_isNormalized_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isNormalized); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_isNormalized_set) + +static bool js_cc_gfx_Attribute_isNormalized_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isNormalized, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_isNormalized_get) + +static bool js_cc_gfx_Attribute_stream_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stream, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_stream_set) + +static bool js_cc_gfx_Attribute_stream_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stream, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_stream_get) + +static bool js_cc_gfx_Attribute_isInstanced_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isInstanced); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_isInstanced_set) + +static bool js_cc_gfx_Attribute_isInstanced_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isInstanced, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_isInstanced_get) + +static bool js_cc_gfx_Attribute_location_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->location, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_Attribute_location_set) + +static bool js_cc_gfx_Attribute_location_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->location, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Attribute_location_get) + +static bool js_cc_gfx_Attribute_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Attribute *arg1 = (cc::gfx::Attribute *) NULL ; + cc::gfx::Attribute *arg2 = 0 ; + cc::gfx::Attribute temp2 ; + cc::gfx::Attribute *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(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::gfx::Attribute *) &(arg1)->copy((cc::gfx::Attribute 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_gfx_Attribute_copy) + +static bool js_new_cc_gfx_Attribute(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::Attribute *result; + result = (cc::gfx::Attribute *)new cc::gfx::Attribute(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Attribute, __jsb_cc_gfx_Attribute_class, js_delete_cc_gfx_Attribute) + +static bool js_delete_cc_gfx_Attribute(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Attribute) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Attribute * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("isNormalized", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isNormalized), ctx); + } + + + json->getProperty("stream", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stream), ctx); + } + + + json->getProperty("isInstanced", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isInstanced), ctx); + } + + + json->getProperty("location", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->location), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_Attribute(se::Object* obj) { + auto* cls = se::Class::create("Attribute", obj, nullptr, _SE(js_new_cc_gfx_Attribute)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_Attribute_name_get), _SE(js_cc_gfx_Attribute_name_set)); + cls->defineProperty("format", _SE(js_cc_gfx_Attribute_format_get), _SE(js_cc_gfx_Attribute_format_set)); + cls->defineProperty("isNormalized", _SE(js_cc_gfx_Attribute_isNormalized_get), _SE(js_cc_gfx_Attribute_isNormalized_set)); + cls->defineProperty("stream", _SE(js_cc_gfx_Attribute_stream_get), _SE(js_cc_gfx_Attribute_stream_set)); + cls->defineProperty("isInstanced", _SE(js_cc_gfx_Attribute_isInstanced_get), _SE(js_cc_gfx_Attribute_isInstanced_set)); + cls->defineProperty("location", _SE(js_cc_gfx_Attribute_location_get), _SE(js_cc_gfx_Attribute_location_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_Attribute_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Attribute)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Attribute_proto = cls->getProto(); + __jsb_cc_gfx_Attribute_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ShaderInfo_class = nullptr; +se::Object* __jsb_cc_gfx_ShaderInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ShaderInfo) + +static bool js_cc_gfx_ShaderInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_name_set) + +static bool js_cc_gfx_ShaderInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_name_get) + +static bool js_cc_gfx_ShaderInfo_stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_stages_set) + +static bool js_cc_gfx_ShaderInfo_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_stages_get) + +static bool js_cc_gfx_ShaderInfo_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_attributes_set) + +static bool js_cc_gfx_ShaderInfo_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_attributes_get) + +static bool js_cc_gfx_ShaderInfo_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_blocks_set) + +static bool js_cc_gfx_ShaderInfo_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_blocks_get) + +static bool js_cc_gfx_ShaderInfo_buffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_buffers_set) + +static bool js_cc_gfx_ShaderInfo_buffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_buffers_get) + +static bool js_cc_gfx_ShaderInfo_samplerTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_samplerTextures_set) + +static bool js_cc_gfx_ShaderInfo_samplerTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_samplerTextures_get) + +static bool js_cc_gfx_ShaderInfo_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_samplers_set) + +static bool js_cc_gfx_ShaderInfo_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_samplers_get) + +static bool js_cc_gfx_ShaderInfo_textures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_textures_set) + +static bool js_cc_gfx_ShaderInfo_textures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->textures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_textures_get) + +static bool js_cc_gfx_ShaderInfo_images_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->images, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_images_set) + +static bool js_cc_gfx_ShaderInfo_images_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->images, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->images, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_images_get) + +static bool js_cc_gfx_ShaderInfo_subpassInputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpassInputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_subpassInputs_set) + +static bool js_cc_gfx_ShaderInfo_subpassInputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpassInputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpassInputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_subpassInputs_get) + +static bool js_cc_gfx_ShaderInfo_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ShaderInfo_hash_set) + +static bool js_cc_gfx_ShaderInfo_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hash, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->hash, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ShaderInfo_hash_get) + +static bool js_cc_gfx_ShaderInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ShaderInfo *arg1 = (cc::gfx::ShaderInfo *) NULL ; + cc::gfx::ShaderInfo *arg2 = 0 ; + cc::gfx::ShaderInfo temp2 ; + cc::gfx::ShaderInfo *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(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::gfx::ShaderInfo *) &(arg1)->copy((cc::gfx::ShaderInfo 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_gfx_ShaderInfo_copy) + +static bool js_new_cc_gfx_ShaderInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ShaderInfo *result; + result = (cc::gfx::ShaderInfo *)new cc::gfx::ShaderInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ShaderInfo, __jsb_cc_gfx_ShaderInfo_class, js_delete_cc_gfx_ShaderInfo) + +static bool js_delete_cc_gfx_ShaderInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ShaderInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("stages", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stages), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("buffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffers), ctx); + } + + + json->getProperty("samplerTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerTextures), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("textures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textures), ctx); + } + + + json->getProperty("images", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->images), ctx); + } + + + json->getProperty("subpassInputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpassInputs), ctx); + } + + + json->getProperty("hash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hash), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ShaderInfo(se::Object* obj) { + auto* cls = se::Class::create("ShaderInfo", obj, nullptr, _SE(js_new_cc_gfx_ShaderInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_ShaderInfo_name_get), _SE(js_cc_gfx_ShaderInfo_name_set)); + cls->defineProperty("stages", _SE(js_cc_gfx_ShaderInfo_stages_get), _SE(js_cc_gfx_ShaderInfo_stages_set)); + cls->defineProperty("attributes", _SE(js_cc_gfx_ShaderInfo_attributes_get), _SE(js_cc_gfx_ShaderInfo_attributes_set)); + cls->defineProperty("blocks", _SE(js_cc_gfx_ShaderInfo_blocks_get), _SE(js_cc_gfx_ShaderInfo_blocks_set)); + cls->defineProperty("buffers", _SE(js_cc_gfx_ShaderInfo_buffers_get), _SE(js_cc_gfx_ShaderInfo_buffers_set)); + cls->defineProperty("samplerTextures", _SE(js_cc_gfx_ShaderInfo_samplerTextures_get), _SE(js_cc_gfx_ShaderInfo_samplerTextures_set)); + cls->defineProperty("samplers", _SE(js_cc_gfx_ShaderInfo_samplers_get), _SE(js_cc_gfx_ShaderInfo_samplers_set)); + cls->defineProperty("textures", _SE(js_cc_gfx_ShaderInfo_textures_get), _SE(js_cc_gfx_ShaderInfo_textures_set)); + cls->defineProperty("images", _SE(js_cc_gfx_ShaderInfo_images_get), _SE(js_cc_gfx_ShaderInfo_images_set)); + cls->defineProperty("subpassInputs", _SE(js_cc_gfx_ShaderInfo_subpassInputs_get), _SE(js_cc_gfx_ShaderInfo_subpassInputs_set)); + cls->defineProperty("hash", _SE(js_cc_gfx_ShaderInfo_hash_get), _SE(js_cc_gfx_ShaderInfo_hash_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_ShaderInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ShaderInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ShaderInfo_proto = cls->getProto(); + __jsb_cc_gfx_ShaderInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_InputAssemblerInfo_class = nullptr; +se::Object* __jsb_cc_gfx_InputAssemblerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_InputAssemblerInfo) + +static bool js_cc_gfx_InputAssemblerInfo_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_attributes_set) + +static bool js_cc_gfx_InputAssemblerInfo_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_attributes_get) + +static bool js_cc_gfx_InputAssemblerInfo_vertexBuffers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertexBuffers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_vertexBuffers_set) + +static bool js_cc_gfx_InputAssemblerInfo_vertexBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertexBuffers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vertexBuffers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_vertexBuffers_get) + +static bool js_cc_gfx_InputAssemblerInfo_indexBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indexBuffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_indexBuffer_set) + +static bool js_cc_gfx_InputAssemblerInfo_indexBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indexBuffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indexBuffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_indexBuffer_get) + +static bool js_cc_gfx_InputAssemblerInfo_indirectBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->indirectBuffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssemblerInfo_indirectBuffer_set) + +static bool js_cc_gfx_InputAssemblerInfo_indirectBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->indirectBuffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->indirectBuffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssemblerInfo_indirectBuffer_get) + +static bool js_cc_gfx_InputAssemblerInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssemblerInfo *arg1 = (cc::gfx::InputAssemblerInfo *) NULL ; + cc::gfx::InputAssemblerInfo *arg2 = 0 ; + cc::gfx::InputAssemblerInfo temp2 ; + cc::gfx::InputAssemblerInfo *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(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::gfx::InputAssemblerInfo *) &(arg1)->copy((cc::gfx::InputAssemblerInfo 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_gfx_InputAssemblerInfo_copy) + +static bool js_new_cc_gfx_InputAssemblerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::InputAssemblerInfo *result; + result = (cc::gfx::InputAssemblerInfo *)new cc::gfx::InputAssemblerInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_InputAssemblerInfo, __jsb_cc_gfx_InputAssemblerInfo_class, js_delete_cc_gfx_InputAssemblerInfo) + +static bool js_delete_cc_gfx_InputAssemblerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_InputAssemblerInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputAssemblerInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + json->getProperty("vertexBuffers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertexBuffers), ctx); + } + + + json->getProperty("indexBuffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indexBuffer), ctx); + } + + + json->getProperty("indirectBuffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->indirectBuffer), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_InputAssemblerInfo(se::Object* obj) { + auto* cls = se::Class::create("InputAssemblerInfo", obj, nullptr, _SE(js_new_cc_gfx_InputAssemblerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attributes", _SE(js_cc_gfx_InputAssemblerInfo_attributes_get), _SE(js_cc_gfx_InputAssemblerInfo_attributes_set)); + cls->defineProperty("vertexBuffers", _SE(js_cc_gfx_InputAssemblerInfo_vertexBuffers_get), _SE(js_cc_gfx_InputAssemblerInfo_vertexBuffers_set)); + cls->defineProperty("indexBuffer", _SE(js_cc_gfx_InputAssemblerInfo_indexBuffer_get), _SE(js_cc_gfx_InputAssemblerInfo_indexBuffer_set)); + cls->defineProperty("indirectBuffer", _SE(js_cc_gfx_InputAssemblerInfo_indirectBuffer_get), _SE(js_cc_gfx_InputAssemblerInfo_indirectBuffer_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_InputAssemblerInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_InputAssemblerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_InputAssemblerInfo_proto = cls->getProto(); + __jsb_cc_gfx_InputAssemblerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ColorAttachment_class = nullptr; +se::Object* __jsb_cc_gfx_ColorAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ColorAttachment) + +static bool js_cc_gfx_ColorAttachment_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_format_set) + +static bool js_cc_gfx_ColorAttachment_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_format_get) + +static bool js_cc_gfx_ColorAttachment_sampleCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampleCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_sampleCount_set) + +static bool js_cc_gfx_ColorAttachment_sampleCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampleCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampleCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_sampleCount_get) + +static bool js_cc_gfx_ColorAttachment_loadOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->loadOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_loadOp_set) + +static bool js_cc_gfx_ColorAttachment_loadOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->loadOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->loadOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_loadOp_get) + +static bool js_cc_gfx_ColorAttachment_storeOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storeOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_storeOp_set) + +static bool js_cc_gfx_ColorAttachment_storeOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storeOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storeOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_storeOp_get) + +static bool js_cc_gfx_ColorAttachment_barrier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->barrier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ColorAttachment_barrier_set) + +static bool js_cc_gfx_ColorAttachment_barrier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->barrier, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->barrier, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ColorAttachment_barrier_get) + +static bool js_cc_gfx_ColorAttachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ColorAttachment *arg1 = (cc::gfx::ColorAttachment *) NULL ; + cc::gfx::ColorAttachment *arg2 = 0 ; + cc::gfx::ColorAttachment temp2 ; + cc::gfx::ColorAttachment *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(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::gfx::ColorAttachment *) &(arg1)->copy((cc::gfx::ColorAttachment 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_gfx_ColorAttachment_copy) + +static bool js_new_cc_gfx_ColorAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ColorAttachment *result; + result = (cc::gfx::ColorAttachment *)new cc::gfx::ColorAttachment(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ColorAttachment, __jsb_cc_gfx_ColorAttachment_class, js_delete_cc_gfx_ColorAttachment) + +static bool js_delete_cc_gfx_ColorAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ColorAttachment) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ColorAttachment * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("sampleCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampleCount), ctx); + } + + + json->getProperty("loadOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->loadOp), ctx); + } + + + json->getProperty("storeOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->storeOp), ctx); + } + + + json->getProperty("barrier", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->barrier), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ColorAttachment(se::Object* obj) { + auto* cls = se::Class::create("ColorAttachment", obj, nullptr, _SE(js_new_cc_gfx_ColorAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("format", _SE(js_cc_gfx_ColorAttachment_format_get), _SE(js_cc_gfx_ColorAttachment_format_set)); + cls->defineProperty("sampleCount", _SE(js_cc_gfx_ColorAttachment_sampleCount_get), _SE(js_cc_gfx_ColorAttachment_sampleCount_set)); + cls->defineProperty("loadOp", _SE(js_cc_gfx_ColorAttachment_loadOp_get), _SE(js_cc_gfx_ColorAttachment_loadOp_set)); + cls->defineProperty("storeOp", _SE(js_cc_gfx_ColorAttachment_storeOp_get), _SE(js_cc_gfx_ColorAttachment_storeOp_set)); + cls->defineProperty("barrier", _SE(js_cc_gfx_ColorAttachment_barrier_get), _SE(js_cc_gfx_ColorAttachment_barrier_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_ColorAttachment_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ColorAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ColorAttachment_proto = cls->getProto(); + __jsb_cc_gfx_ColorAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DepthStencilAttachment_class = nullptr; +se::Object* __jsb_cc_gfx_DepthStencilAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilAttachment) + +static bool js_cc_gfx_DepthStencilAttachment_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_format_set) + +static bool js_cc_gfx_DepthStencilAttachment_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_format_get) + +static bool js_cc_gfx_DepthStencilAttachment_sampleCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampleCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_sampleCount_set) + +static bool js_cc_gfx_DepthStencilAttachment_sampleCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampleCount, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampleCount, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_sampleCount_get) + +static bool js_cc_gfx_DepthStencilAttachment_depthLoadOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthLoadOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_depthLoadOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_depthLoadOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthLoadOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthLoadOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_depthLoadOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_depthStoreOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStoreOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_depthStoreOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_depthStoreOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStoreOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStoreOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_depthStoreOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_stencilLoadOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilLoadOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_stencilLoadOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilLoadOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilLoadOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_stencilStoreOp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilStoreOp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_set) + +static bool js_cc_gfx_DepthStencilAttachment_stencilStoreOp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilStoreOp, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilStoreOp, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_get) + +static bool js_cc_gfx_DepthStencilAttachment_barrier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->barrier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilAttachment_barrier_set) + +static bool js_cc_gfx_DepthStencilAttachment_barrier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->barrier, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->barrier, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilAttachment_barrier_get) + +static bool js_cc_gfx_DepthStencilAttachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilAttachment *arg1 = (cc::gfx::DepthStencilAttachment *) NULL ; + cc::gfx::DepthStencilAttachment *arg2 = 0 ; + cc::gfx::DepthStencilAttachment temp2 ; + cc::gfx::DepthStencilAttachment *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(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::gfx::DepthStencilAttachment *) &(arg1)->copy((cc::gfx::DepthStencilAttachment 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_gfx_DepthStencilAttachment_copy) + +static bool js_new_cc_gfx_DepthStencilAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DepthStencilAttachment *result; + result = (cc::gfx::DepthStencilAttachment *)new cc::gfx::DepthStencilAttachment(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DepthStencilAttachment, __jsb_cc_gfx_DepthStencilAttachment_class, js_delete_cc_gfx_DepthStencilAttachment) + +static bool js_delete_cc_gfx_DepthStencilAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilAttachment) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilAttachment * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("sampleCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampleCount), ctx); + } + + + json->getProperty("depthLoadOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthLoadOp), ctx); + } + + + json->getProperty("depthStoreOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStoreOp), ctx); + } + + + json->getProperty("stencilLoadOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilLoadOp), ctx); + } + + + json->getProperty("stencilStoreOp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilStoreOp), ctx); + } + + + json->getProperty("barrier", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->barrier), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DepthStencilAttachment(se::Object* obj) { + auto* cls = se::Class::create("DepthStencilAttachment", obj, nullptr, _SE(js_new_cc_gfx_DepthStencilAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("format", _SE(js_cc_gfx_DepthStencilAttachment_format_get), _SE(js_cc_gfx_DepthStencilAttachment_format_set)); + cls->defineProperty("sampleCount", _SE(js_cc_gfx_DepthStencilAttachment_sampleCount_get), _SE(js_cc_gfx_DepthStencilAttachment_sampleCount_set)); + cls->defineProperty("depthLoadOp", _SE(js_cc_gfx_DepthStencilAttachment_depthLoadOp_get), _SE(js_cc_gfx_DepthStencilAttachment_depthLoadOp_set)); + cls->defineProperty("depthStoreOp", _SE(js_cc_gfx_DepthStencilAttachment_depthStoreOp_get), _SE(js_cc_gfx_DepthStencilAttachment_depthStoreOp_set)); + cls->defineProperty("stencilLoadOp", _SE(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_get), _SE(js_cc_gfx_DepthStencilAttachment_stencilLoadOp_set)); + cls->defineProperty("stencilStoreOp", _SE(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_get), _SE(js_cc_gfx_DepthStencilAttachment_stencilStoreOp_set)); + cls->defineProperty("barrier", _SE(js_cc_gfx_DepthStencilAttachment_barrier_get), _SE(js_cc_gfx_DepthStencilAttachment_barrier_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DepthStencilAttachment_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DepthStencilAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DepthStencilAttachment_proto = cls->getProto(); + __jsb_cc_gfx_DepthStencilAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SubpassInfo_class = nullptr; +se::Object* __jsb_cc_gfx_SubpassInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SubpassInfo) + +static bool js_cc_gfx_SubpassInfo_inputs_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inputs, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_inputs_set) + +static bool js_cc_gfx_SubpassInfo_inputs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inputs, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->inputs, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_inputs_get) + +static bool js_cc_gfx_SubpassInfo_colors_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colors, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_colors_set) + +static bool js_cc_gfx_SubpassInfo_colors_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colors, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colors, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_colors_get) + +static bool js_cc_gfx_SubpassInfo_resolves_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->resolves, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_resolves_set) + +static bool js_cc_gfx_SubpassInfo_resolves_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->resolves, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->resolves, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_resolves_get) + +static bool js_cc_gfx_SubpassInfo_preserves_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->preserves, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_preserves_set) + +static bool js_cc_gfx_SubpassInfo_preserves_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->preserves, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->preserves, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_preserves_get) + +static bool js_cc_gfx_SubpassInfo_depthStencil_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencil, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_depthStencil_set) + +static bool js_cc_gfx_SubpassInfo_depthStencil_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencil, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_depthStencil_get) + +static bool js_cc_gfx_SubpassInfo_depthStencilResolve_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilResolve, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_depthStencilResolve_set) + +static bool js_cc_gfx_SubpassInfo_depthStencilResolve_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilResolve, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_depthStencilResolve_get) + +static bool js_cc_gfx_SubpassInfo_shadingRate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadingRate, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_shadingRate_set) + +static bool js_cc_gfx_SubpassInfo_shadingRate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadingRate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_shadingRate_get) + +static bool js_cc_gfx_SubpassInfo_depthResolveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthResolveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_depthResolveMode_set) + +static bool js_cc_gfx_SubpassInfo_depthResolveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthResolveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthResolveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_depthResolveMode_get) + +static bool js_cc_gfx_SubpassInfo_stencilResolveMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilResolveMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassInfo_stencilResolveMode_set) + +static bool js_cc_gfx_SubpassInfo_stencilResolveMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilResolveMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilResolveMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassInfo_stencilResolveMode_get) + +static bool js_cc_gfx_SubpassInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassInfo *arg1 = (cc::gfx::SubpassInfo *) NULL ; + cc::gfx::SubpassInfo *arg2 = 0 ; + cc::gfx::SubpassInfo temp2 ; + cc::gfx::SubpassInfo *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(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::gfx::SubpassInfo *) &(arg1)->copy((cc::gfx::SubpassInfo 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_gfx_SubpassInfo_copy) + +static bool js_new_cc_gfx_SubpassInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SubpassInfo *result; + result = (cc::gfx::SubpassInfo *)new cc::gfx::SubpassInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SubpassInfo, __jsb_cc_gfx_SubpassInfo_class, js_delete_cc_gfx_SubpassInfo) + +static bool js_delete_cc_gfx_SubpassInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SubpassInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("inputs", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->inputs), ctx); + } + + + json->getProperty("colors", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colors), ctx); + } + + + json->getProperty("resolves", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->resolves), ctx); + } + + + json->getProperty("preserves", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->preserves), ctx); + } + + + json->getProperty("depthStencil", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencil), ctx); + } + + + json->getProperty("depthStencilResolve", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilResolve), ctx); + } + + + json->getProperty("shadingRate", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadingRate), ctx); + } + + + json->getProperty("depthResolveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthResolveMode), ctx); + } + + + json->getProperty("stencilResolveMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilResolveMode), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SubpassInfo(se::Object* obj) { + auto* cls = se::Class::create("SubpassInfo", obj, nullptr, _SE(js_new_cc_gfx_SubpassInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("inputs", _SE(js_cc_gfx_SubpassInfo_inputs_get), _SE(js_cc_gfx_SubpassInfo_inputs_set)); + cls->defineProperty("colors", _SE(js_cc_gfx_SubpassInfo_colors_get), _SE(js_cc_gfx_SubpassInfo_colors_set)); + cls->defineProperty("resolves", _SE(js_cc_gfx_SubpassInfo_resolves_get), _SE(js_cc_gfx_SubpassInfo_resolves_set)); + cls->defineProperty("preserves", _SE(js_cc_gfx_SubpassInfo_preserves_get), _SE(js_cc_gfx_SubpassInfo_preserves_set)); + cls->defineProperty("depthStencil", _SE(js_cc_gfx_SubpassInfo_depthStencil_get), _SE(js_cc_gfx_SubpassInfo_depthStencil_set)); + cls->defineProperty("depthStencilResolve", _SE(js_cc_gfx_SubpassInfo_depthStencilResolve_get), _SE(js_cc_gfx_SubpassInfo_depthStencilResolve_set)); + cls->defineProperty("shadingRate", _SE(js_cc_gfx_SubpassInfo_shadingRate_get), _SE(js_cc_gfx_SubpassInfo_shadingRate_set)); + cls->defineProperty("depthResolveMode", _SE(js_cc_gfx_SubpassInfo_depthResolveMode_get), _SE(js_cc_gfx_SubpassInfo_depthResolveMode_set)); + cls->defineProperty("stencilResolveMode", _SE(js_cc_gfx_SubpassInfo_stencilResolveMode_get), _SE(js_cc_gfx_SubpassInfo_stencilResolveMode_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SubpassInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SubpassInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SubpassInfo_proto = cls->getProto(); + __jsb_cc_gfx_SubpassInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_SubpassDependency_class = nullptr; +se::Object* __jsb_cc_gfx_SubpassDependency_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_SubpassDependency) + +static bool js_cc_gfx_SubpassDependency_srcSubpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcSubpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_srcSubpass_set) + +static bool js_cc_gfx_SubpassDependency_srcSubpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcSubpass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_srcSubpass_get) + +static bool js_cc_gfx_SubpassDependency_dstSubpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstSubpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_dstSubpass_set) + +static bool js_cc_gfx_SubpassDependency_dstSubpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstSubpass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_dstSubpass_get) + +static bool js_cc_gfx_SubpassDependency_generalBarrier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->generalBarrier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_generalBarrier_set) + +static bool js_cc_gfx_SubpassDependency_generalBarrier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->generalBarrier, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->generalBarrier, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_generalBarrier_get) + +static bool js_cc_gfx_SubpassDependency_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_prevAccesses_set) + +static bool js_cc_gfx_SubpassDependency_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_prevAccesses_get) + +static bool js_cc_gfx_SubpassDependency_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_SubpassDependency_nextAccesses_set) + +static bool js_cc_gfx_SubpassDependency_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_SubpassDependency_nextAccesses_get) + +static bool js_cc_gfx_SubpassDependency_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SubpassDependency *arg1 = (cc::gfx::SubpassDependency *) NULL ; + cc::gfx::SubpassDependency *arg2 = 0 ; + cc::gfx::SubpassDependency temp2 ; + cc::gfx::SubpassDependency *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(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::gfx::SubpassDependency *) &(arg1)->copy((cc::gfx::SubpassDependency 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_gfx_SubpassDependency_copy) + +static bool js_new_cc_gfx_SubpassDependency(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::SubpassDependency *result; + result = (cc::gfx::SubpassDependency *)new cc::gfx::SubpassDependency(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_SubpassDependency, __jsb_cc_gfx_SubpassDependency_class, js_delete_cc_gfx_SubpassDependency) + +static bool js_delete_cc_gfx_SubpassDependency(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_SubpassDependency) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassDependency * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("srcSubpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcSubpass), ctx); + } + + + json->getProperty("dstSubpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstSubpass), ctx); + } + + + json->getProperty("generalBarrier", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->generalBarrier), ctx); + } + + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_SubpassDependency(se::Object* obj) { + auto* cls = se::Class::create("SubpassDependency", obj, nullptr, _SE(js_new_cc_gfx_SubpassDependency)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("srcSubpass", _SE(js_cc_gfx_SubpassDependency_srcSubpass_get), _SE(js_cc_gfx_SubpassDependency_srcSubpass_set)); + cls->defineProperty("dstSubpass", _SE(js_cc_gfx_SubpassDependency_dstSubpass_get), _SE(js_cc_gfx_SubpassDependency_dstSubpass_set)); + cls->defineProperty("generalBarrier", _SE(js_cc_gfx_SubpassDependency_generalBarrier_get), _SE(js_cc_gfx_SubpassDependency_generalBarrier_set)); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_SubpassDependency_prevAccesses_get), _SE(js_cc_gfx_SubpassDependency_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_SubpassDependency_nextAccesses_get), _SE(js_cc_gfx_SubpassDependency_nextAccesses_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_SubpassDependency_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_SubpassDependency)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_SubpassDependency_proto = cls->getProto(); + __jsb_cc_gfx_SubpassDependency_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_RenderPassInfo_class = nullptr; +se::Object* __jsb_cc_gfx_RenderPassInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_RenderPassInfo) + +static bool js_cc_gfx_RenderPassInfo_colorAttachments_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorAttachments, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_colorAttachments_set) + +static bool js_cc_gfx_RenderPassInfo_colorAttachments_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorAttachments, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorAttachments, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_colorAttachments_get) + +static bool js_cc_gfx_RenderPassInfo_depthStencilAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilAttachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_depthStencilAttachment_set) + +static bool js_cc_gfx_RenderPassInfo_depthStencilAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilAttachment, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilAttachment, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_depthStencilAttachment_get) + +static bool js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilResolveAttachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_set) + +static bool js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilResolveAttachment, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilResolveAttachment, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_get) + +static bool js_cc_gfx_RenderPassInfo_subpasses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpasses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_subpasses_set) + +static bool js_cc_gfx_RenderPassInfo_subpasses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpasses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpasses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_subpasses_get) + +static bool js_cc_gfx_RenderPassInfo_dependencies_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dependencies, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RenderPassInfo_dependencies_set) + +static bool js_cc_gfx_RenderPassInfo_dependencies_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dependencies, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dependencies, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RenderPassInfo_dependencies_get) + +static bool js_cc_gfx_RenderPassInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = (cc::gfx::RenderPassInfo *) NULL ; + cc::gfx::RenderPassInfo *arg2 = 0 ; + cc::gfx::RenderPassInfo temp2 ; + cc::gfx::RenderPassInfo *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(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::gfx::RenderPassInfo *) &(arg1)->copy((cc::gfx::RenderPassInfo 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_gfx_RenderPassInfo_copy) + +static bool js_new_cc_gfx_RenderPassInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::RenderPassInfo *result; + result = (cc::gfx::RenderPassInfo *)new cc::gfx::RenderPassInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_RenderPassInfo, __jsb_cc_gfx_RenderPassInfo_class, js_delete_cc_gfx_RenderPassInfo) + +static bool js_delete_cc_gfx_RenderPassInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_RenderPassInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RenderPassInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("colorAttachments", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorAttachments), ctx); + } + + + json->getProperty("depthStencilAttachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilAttachment), ctx); + } + + + json->getProperty("depthStencilResolveAttachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilResolveAttachment), ctx); + } + + + json->getProperty("subpasses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpasses), ctx); + } + + + json->getProperty("dependencies", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dependencies), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_RenderPassInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderPassInfo", obj, nullptr, _SE(js_new_cc_gfx_RenderPassInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("colorAttachments", _SE(js_cc_gfx_RenderPassInfo_colorAttachments_get), _SE(js_cc_gfx_RenderPassInfo_colorAttachments_set)); + cls->defineProperty("depthStencilAttachment", _SE(js_cc_gfx_RenderPassInfo_depthStencilAttachment_get), _SE(js_cc_gfx_RenderPassInfo_depthStencilAttachment_set)); + cls->defineProperty("depthStencilResolveAttachment", _SE(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_get), _SE(js_cc_gfx_RenderPassInfo_depthStencilResolveAttachment_set)); + cls->defineProperty("subpasses", _SE(js_cc_gfx_RenderPassInfo_subpasses_get), _SE(js_cc_gfx_RenderPassInfo_subpasses_set)); + cls->defineProperty("dependencies", _SE(js_cc_gfx_RenderPassInfo_dependencies_get), _SE(js_cc_gfx_RenderPassInfo_dependencies_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_RenderPassInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_RenderPassInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_RenderPassInfo_proto = cls->getProto(); + __jsb_cc_gfx_RenderPassInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_ResourceRange_class = nullptr; +se::Object* __jsb_cc_gfx_ResourceRange_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_ResourceRange) + +static bool js_cc_gfx_ResourceRange_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_width_set) + +static bool js_cc_gfx_ResourceRange_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_width_get) + +static bool js_cc_gfx_ResourceRange_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_height_set) + +static bool js_cc_gfx_ResourceRange_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_height_get) + +static bool js_cc_gfx_ResourceRange_depthOrArraySize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthOrArraySize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_depthOrArraySize_set) + +static bool js_cc_gfx_ResourceRange_depthOrArraySize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthOrArraySize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_depthOrArraySize_get) + +static bool js_cc_gfx_ResourceRange_firstSlice_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->firstSlice, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_firstSlice_set) + +static bool js_cc_gfx_ResourceRange_firstSlice_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->firstSlice, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_firstSlice_get) + +static bool js_cc_gfx_ResourceRange_numSlices_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->numSlices, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_numSlices_set) + +static bool js_cc_gfx_ResourceRange_numSlices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->numSlices, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_numSlices_get) + +static bool js_cc_gfx_ResourceRange_mipLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->mipLevel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_mipLevel_set) + +static bool js_cc_gfx_ResourceRange_mipLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->mipLevel, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_mipLevel_get) + +static bool js_cc_gfx_ResourceRange_levelCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->levelCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_levelCount_set) + +static bool js_cc_gfx_ResourceRange_levelCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->levelCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_levelCount_get) + +static bool js_cc_gfx_ResourceRange_basePlane_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->basePlane, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_basePlane_set) + +static bool js_cc_gfx_ResourceRange_basePlane_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->basePlane, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_basePlane_get) + +static bool js_cc_gfx_ResourceRange_planeCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->planeCount, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_ResourceRange_planeCount_set) + +static bool js_cc_gfx_ResourceRange_planeCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::ResourceRange *arg1 = (cc::gfx::ResourceRange *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->planeCount, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_ResourceRange_planeCount_get) + +static bool js_new_cc_gfx_ResourceRange(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::ResourceRange *result; + result = (cc::gfx::ResourceRange *)new cc::gfx::ResourceRange(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_ResourceRange, __jsb_cc_gfx_ResourceRange_class, js_delete_cc_gfx_ResourceRange) + +static bool js_delete_cc_gfx_ResourceRange(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_ResourceRange) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ResourceRange * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("depthOrArraySize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthOrArraySize), ctx); + } + + + json->getProperty("firstSlice", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->firstSlice), ctx); + } + + + json->getProperty("numSlices", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->numSlices), ctx); + } + + + json->getProperty("mipLevel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->mipLevel), ctx); + } + + + json->getProperty("levelCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->levelCount), ctx); + } + + + json->getProperty("basePlane", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->basePlane), ctx); + } + + + json->getProperty("planeCount", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->planeCount), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_ResourceRange(se::Object* obj) { + auto* cls = se::Class::create("ResourceRange", obj, nullptr, _SE(js_new_cc_gfx_ResourceRange)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_gfx_ResourceRange_width_get), _SE(js_cc_gfx_ResourceRange_width_set)); + cls->defineProperty("height", _SE(js_cc_gfx_ResourceRange_height_get), _SE(js_cc_gfx_ResourceRange_height_set)); + cls->defineProperty("depthOrArraySize", _SE(js_cc_gfx_ResourceRange_depthOrArraySize_get), _SE(js_cc_gfx_ResourceRange_depthOrArraySize_set)); + cls->defineProperty("firstSlice", _SE(js_cc_gfx_ResourceRange_firstSlice_get), _SE(js_cc_gfx_ResourceRange_firstSlice_set)); + cls->defineProperty("numSlices", _SE(js_cc_gfx_ResourceRange_numSlices_get), _SE(js_cc_gfx_ResourceRange_numSlices_set)); + cls->defineProperty("mipLevel", _SE(js_cc_gfx_ResourceRange_mipLevel_get), _SE(js_cc_gfx_ResourceRange_mipLevel_set)); + cls->defineProperty("levelCount", _SE(js_cc_gfx_ResourceRange_levelCount_get), _SE(js_cc_gfx_ResourceRange_levelCount_set)); + cls->defineProperty("basePlane", _SE(js_cc_gfx_ResourceRange_basePlane_get), _SE(js_cc_gfx_ResourceRange_basePlane_set)); + cls->defineProperty("planeCount", _SE(js_cc_gfx_ResourceRange_planeCount_get), _SE(js_cc_gfx_ResourceRange_planeCount_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_ResourceRange)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_ResourceRange_proto = cls->getProto(); + __jsb_cc_gfx_ResourceRange_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_GeneralBarrierInfo_class = nullptr; +se::Object* __jsb_cc_gfx_GeneralBarrierInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrierInfo) + +static bool js_cc_gfx_GeneralBarrierInfo_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo_prevAccesses_set) + +static bool js_cc_gfx_GeneralBarrierInfo_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo_prevAccesses_get) + +static bool js_cc_gfx_GeneralBarrierInfo_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo_nextAccesses_set) + +static bool js_cc_gfx_GeneralBarrierInfo_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo_nextAccesses_get) + +static bool js_cc_gfx_GeneralBarrierInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo_type_set) + +static bool js_cc_gfx_GeneralBarrierInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo_type_get) + +static bool js_cc_gfx_GeneralBarrierInfo__padding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_padding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_GeneralBarrierInfo__padding_set) + +static bool js_cc_gfx_GeneralBarrierInfo__padding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_padding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GeneralBarrierInfo__padding_get) + +static bool js_cc_gfx_GeneralBarrierInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = (cc::gfx::GeneralBarrierInfo *) NULL ; + cc::gfx::GeneralBarrierInfo *arg2 = 0 ; + cc::gfx::GeneralBarrierInfo temp2 ; + cc::gfx::GeneralBarrierInfo *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(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::gfx::GeneralBarrierInfo *) &(arg1)->copy((cc::gfx::GeneralBarrierInfo 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_gfx_GeneralBarrierInfo_copy) + +static bool js_new_cc_gfx_GeneralBarrierInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::GeneralBarrierInfo *result; + result = (cc::gfx::GeneralBarrierInfo *)new cc::gfx::GeneralBarrierInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_GeneralBarrierInfo, __jsb_cc_gfx_GeneralBarrierInfo_class, js_delete_cc_gfx_GeneralBarrierInfo) + +static bool js_delete_cc_gfx_GeneralBarrierInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrierInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::GeneralBarrierInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("_padding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_padding), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_GeneralBarrierInfo(se::Object* obj) { + auto* cls = se::Class::create("GeneralBarrierInfo", obj, nullptr, _SE(js_new_cc_gfx_GeneralBarrierInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_GeneralBarrierInfo_prevAccesses_get), _SE(js_cc_gfx_GeneralBarrierInfo_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_GeneralBarrierInfo_nextAccesses_get), _SE(js_cc_gfx_GeneralBarrierInfo_nextAccesses_set)); + cls->defineProperty("type", _SE(js_cc_gfx_GeneralBarrierInfo_type_get), _SE(js_cc_gfx_GeneralBarrierInfo_type_set)); + cls->defineProperty("_padding", _SE(js_cc_gfx_GeneralBarrierInfo__padding_get), _SE(js_cc_gfx_GeneralBarrierInfo__padding_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_GeneralBarrierInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_GeneralBarrierInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_GeneralBarrierInfo_proto = cls->getProto(); + __jsb_cc_gfx_GeneralBarrierInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureBarrierInfo_class = nullptr; +se::Object* __jsb_cc_gfx_TextureBarrierInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrierInfo) + +static bool js_cc_gfx_TextureBarrierInfo_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_prevAccesses_set) + +static bool js_cc_gfx_TextureBarrierInfo_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_prevAccesses_get) + +static bool js_cc_gfx_TextureBarrierInfo_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_nextAccesses_set) + +static bool js_cc_gfx_TextureBarrierInfo_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_nextAccesses_get) + +static bool js_cc_gfx_TextureBarrierInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_type_set) + +static bool js_cc_gfx_TextureBarrierInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_type_get) + +static bool js_cc_gfx_TextureBarrierInfo_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->range, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_range_set) + +static bool js_cc_gfx_TextureBarrierInfo_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->range, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->range, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_range_get) + +static bool js_cc_gfx_TextureBarrierInfo_discardContents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->discardContents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_discardContents_set) + +static bool js_cc_gfx_TextureBarrierInfo_discardContents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->discardContents, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_discardContents_get) + +static bool js_cc_gfx_TextureBarrierInfo_srcQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_srcQueue_set) + +static bool js_cc_gfx_TextureBarrierInfo_srcQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_srcQueue_get) + +static bool js_cc_gfx_TextureBarrierInfo_dstQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_TextureBarrierInfo_dstQueue_set) + +static bool js_cc_gfx_TextureBarrierInfo_dstQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_TextureBarrierInfo_dstQueue_get) + +static bool js_cc_gfx_TextureBarrierInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = (cc::gfx::TextureBarrierInfo *) NULL ; + cc::gfx::TextureBarrierInfo *arg2 = 0 ; + cc::gfx::TextureBarrierInfo temp2 ; + cc::gfx::TextureBarrierInfo *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(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::gfx::TextureBarrierInfo *) &(arg1)->copy((cc::gfx::TextureBarrierInfo 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_gfx_TextureBarrierInfo_copy) + +static bool js_new_cc_gfx_TextureBarrierInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::TextureBarrierInfo *result; + result = (cc::gfx::TextureBarrierInfo *)new cc::gfx::TextureBarrierInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureBarrierInfo, __jsb_cc_gfx_TextureBarrierInfo_class, js_delete_cc_gfx_TextureBarrierInfo) + +static bool js_delete_cc_gfx_TextureBarrierInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrierInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBarrierInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("range", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->range), ctx); + } + + + json->getProperty("discardContents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->discardContents), ctx); + } + + + json->getProperty("srcQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcQueue), ctx); + } + + + json->getProperty("dstQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstQueue), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_TextureBarrierInfo(se::Object* obj) { + auto* cls = se::Class::create("TextureBarrierInfo", obj, nullptr, _SE(js_new_cc_gfx_TextureBarrierInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_TextureBarrierInfo_prevAccesses_get), _SE(js_cc_gfx_TextureBarrierInfo_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_TextureBarrierInfo_nextAccesses_get), _SE(js_cc_gfx_TextureBarrierInfo_nextAccesses_set)); + cls->defineProperty("type", _SE(js_cc_gfx_TextureBarrierInfo_type_get), _SE(js_cc_gfx_TextureBarrierInfo_type_set)); + cls->defineProperty("range", _SE(js_cc_gfx_TextureBarrierInfo_range_get), _SE(js_cc_gfx_TextureBarrierInfo_range_set)); + cls->defineProperty("discardContents", _SE(js_cc_gfx_TextureBarrierInfo_discardContents_get), _SE(js_cc_gfx_TextureBarrierInfo_discardContents_set)); + cls->defineProperty("srcQueue", _SE(js_cc_gfx_TextureBarrierInfo_srcQueue_get), _SE(js_cc_gfx_TextureBarrierInfo_srcQueue_set)); + cls->defineProperty("dstQueue", _SE(js_cc_gfx_TextureBarrierInfo_dstQueue_get), _SE(js_cc_gfx_TextureBarrierInfo_dstQueue_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_TextureBarrierInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureBarrierInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureBarrierInfo_proto = cls->getProto(); + __jsb_cc_gfx_TextureBarrierInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferBarrierInfo_class = nullptr; +se::Object* __jsb_cc_gfx_BufferBarrierInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrierInfo) + +static bool js_cc_gfx_BufferBarrierInfo_prevAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->prevAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_prevAccesses_set) + +static bool js_cc_gfx_BufferBarrierInfo_prevAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->prevAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->prevAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_prevAccesses_get) + +static bool js_cc_gfx_BufferBarrierInfo_nextAccesses_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->nextAccesses, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_nextAccesses_set) + +static bool js_cc_gfx_BufferBarrierInfo_nextAccesses_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->nextAccesses, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->nextAccesses, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_nextAccesses_get) + +static bool js_cc_gfx_BufferBarrierInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_type_set) + +static bool js_cc_gfx_BufferBarrierInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_type_get) + +static bool js_cc_gfx_BufferBarrierInfo_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_offset_set) + +static bool js_cc_gfx_BufferBarrierInfo_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_offset_get) + +static bool js_cc_gfx_BufferBarrierInfo_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_size_set) + +static bool js_cc_gfx_BufferBarrierInfo_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_size_get) + +static bool js_cc_gfx_BufferBarrierInfo__padding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_padding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo__padding_set) + +static bool js_cc_gfx_BufferBarrierInfo__padding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_padding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo__padding_get) + +static bool js_cc_gfx_BufferBarrierInfo_discardContents_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->discardContents, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_discardContents_set) + +static bool js_cc_gfx_BufferBarrierInfo_discardContents_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->discardContents, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_discardContents_get) + +static bool js_cc_gfx_BufferBarrierInfo_srcQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->srcQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_srcQueue_set) + +static bool js_cc_gfx_BufferBarrierInfo_srcQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->srcQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->srcQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_srcQueue_get) + +static bool js_cc_gfx_BufferBarrierInfo_dstQueue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dstQueue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BufferBarrierInfo_dstQueue_set) + +static bool js_cc_gfx_BufferBarrierInfo_dstQueue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dstQueue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dstQueue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BufferBarrierInfo_dstQueue_get) + +static bool js_cc_gfx_BufferBarrierInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = (cc::gfx::BufferBarrierInfo *) NULL ; + cc::gfx::BufferBarrierInfo *arg2 = 0 ; + cc::gfx::BufferBarrierInfo temp2 ; + cc::gfx::BufferBarrierInfo *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(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::gfx::BufferBarrierInfo *) &(arg1)->copy((cc::gfx::BufferBarrierInfo 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_gfx_BufferBarrierInfo_copy) + +static bool js_new_cc_gfx_BufferBarrierInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BufferBarrierInfo *result; + result = (cc::gfx::BufferBarrierInfo *)new cc::gfx::BufferBarrierInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BufferBarrierInfo, __jsb_cc_gfx_BufferBarrierInfo_class, js_delete_cc_gfx_BufferBarrierInfo) + +static bool js_delete_cc_gfx_BufferBarrierInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrierInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferBarrierInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("prevAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->prevAccesses), ctx); + } + + + json->getProperty("nextAccesses", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->nextAccesses), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("_padding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_padding), ctx); + } + + + json->getProperty("discardContents", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->discardContents), ctx); + } + + + json->getProperty("srcQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->srcQueue), ctx); + } + + + json->getProperty("dstQueue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dstQueue), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BufferBarrierInfo(se::Object* obj) { + auto* cls = se::Class::create("BufferBarrierInfo", obj, nullptr, _SE(js_new_cc_gfx_BufferBarrierInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("prevAccesses", _SE(js_cc_gfx_BufferBarrierInfo_prevAccesses_get), _SE(js_cc_gfx_BufferBarrierInfo_prevAccesses_set)); + cls->defineProperty("nextAccesses", _SE(js_cc_gfx_BufferBarrierInfo_nextAccesses_get), _SE(js_cc_gfx_BufferBarrierInfo_nextAccesses_set)); + cls->defineProperty("type", _SE(js_cc_gfx_BufferBarrierInfo_type_get), _SE(js_cc_gfx_BufferBarrierInfo_type_set)); + cls->defineProperty("offset", _SE(js_cc_gfx_BufferBarrierInfo_offset_get), _SE(js_cc_gfx_BufferBarrierInfo_offset_set)); + cls->defineProperty("size", _SE(js_cc_gfx_BufferBarrierInfo_size_get), _SE(js_cc_gfx_BufferBarrierInfo_size_set)); + cls->defineProperty("_padding", _SE(js_cc_gfx_BufferBarrierInfo__padding_get), _SE(js_cc_gfx_BufferBarrierInfo__padding_set)); + cls->defineProperty("discardContents", _SE(js_cc_gfx_BufferBarrierInfo_discardContents_get), _SE(js_cc_gfx_BufferBarrierInfo_discardContents_set)); + cls->defineProperty("srcQueue", _SE(js_cc_gfx_BufferBarrierInfo_srcQueue_get), _SE(js_cc_gfx_BufferBarrierInfo_srcQueue_set)); + cls->defineProperty("dstQueue", _SE(js_cc_gfx_BufferBarrierInfo_dstQueue_get), _SE(js_cc_gfx_BufferBarrierInfo_dstQueue_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_BufferBarrierInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferBarrierInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferBarrierInfo_proto = cls->getProto(); + __jsb_cc_gfx_BufferBarrierInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_FramebufferInfo_class = nullptr; +se::Object* __jsb_cc_gfx_FramebufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_FramebufferInfo) + +static bool js_cc_gfx_FramebufferInfo_renderPass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_renderPass_set) + +static bool js_cc_gfx_FramebufferInfo_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPass, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderPass, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_renderPass_get) + +static bool js_cc_gfx_FramebufferInfo_colorTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_colorTextures_set) + +static bool js_cc_gfx_FramebufferInfo_colorTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_colorTextures_get) + +static bool js_cc_gfx_FramebufferInfo_depthStencilTexture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilTexture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_depthStencilTexture_set) + +static bool js_cc_gfx_FramebufferInfo_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilTexture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilTexture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_depthStencilTexture_get) + +static bool js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilResolveTexture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_set) + +static bool js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilResolveTexture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilResolveTexture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_get) + +static bool js_cc_gfx_FramebufferInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = (cc::gfx::FramebufferInfo *) NULL ; + cc::gfx::FramebufferInfo *arg2 = 0 ; + cc::gfx::FramebufferInfo temp2 ; + cc::gfx::FramebufferInfo *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(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::gfx::FramebufferInfo *) &(arg1)->copy((cc::gfx::FramebufferInfo 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_gfx_FramebufferInfo_copy) + +static bool js_new_cc_gfx_FramebufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::FramebufferInfo *result; + result = (cc::gfx::FramebufferInfo *)new cc::gfx::FramebufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_FramebufferInfo, __jsb_cc_gfx_FramebufferInfo_class, js_delete_cc_gfx_FramebufferInfo) + +static bool js_delete_cc_gfx_FramebufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_FramebufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FramebufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("renderPass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPass), ctx); + } + + + json->getProperty("colorTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorTextures), ctx); + } + + + json->getProperty("depthStencilTexture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilTexture), ctx); + } + + + json->getProperty("depthStencilResolveTexture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilResolveTexture), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_FramebufferInfo(se::Object* obj) { + auto* cls = se::Class::create("FramebufferInfo", obj, nullptr, _SE(js_new_cc_gfx_FramebufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderPass", _SE(js_cc_gfx_FramebufferInfo_renderPass_get), _SE(js_cc_gfx_FramebufferInfo_renderPass_set)); + cls->defineProperty("colorTextures", _SE(js_cc_gfx_FramebufferInfo_colorTextures_get), _SE(js_cc_gfx_FramebufferInfo_colorTextures_set)); + cls->defineProperty("depthStencilTexture", _SE(js_cc_gfx_FramebufferInfo_depthStencilTexture_get), _SE(js_cc_gfx_FramebufferInfo_depthStencilTexture_set)); + cls->defineProperty("depthStencilResolveTexture", _SE(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_get), _SE(js_cc_gfx_FramebufferInfo_depthStencilResolveTexture_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_FramebufferInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_FramebufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_FramebufferInfo_proto = cls->getProto(); + __jsb_cc_gfx_FramebufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetLayoutBinding_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetLayoutBinding_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutBinding) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_binding_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->binding, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_binding_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_binding_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->binding, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_binding_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->descriptorType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->descriptorType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->descriptorType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_count_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_count_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stageFlags, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stageFlags, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stageFlags, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_access_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->access, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_access_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_access_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->access, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->access, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_access_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->viewDimension, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->viewDimension, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->viewDimension, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_sampleType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampleType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_sampleType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampleType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampleType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_format_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_format_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->immutableSamplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_set) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->immutableSamplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->immutableSamplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_get) + +static bool js_cc_gfx_DescriptorSetLayoutBinding_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutBinding *arg1 = (cc::gfx::DescriptorSetLayoutBinding *) NULL ; + cc::gfx::DescriptorSetLayoutBinding *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutBinding temp2 ; + cc::gfx::DescriptorSetLayoutBinding *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(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::gfx::DescriptorSetLayoutBinding *) &(arg1)->copy((cc::gfx::DescriptorSetLayoutBinding 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_gfx_DescriptorSetLayoutBinding_copy) + +static bool js_new_cc_gfx_DescriptorSetLayoutBinding(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DescriptorSetLayoutBinding *result; + result = (cc::gfx::DescriptorSetLayoutBinding *)new cc::gfx::DescriptorSetLayoutBinding(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DescriptorSetLayoutBinding, __jsb_cc_gfx_DescriptorSetLayoutBinding_class, js_delete_cc_gfx_DescriptorSetLayoutBinding) + +static bool js_delete_cc_gfx_DescriptorSetLayoutBinding(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutBinding) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutBinding * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("binding", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->binding), ctx); + } + + + json->getProperty("descriptorType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->descriptorType), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("stageFlags", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stageFlags), ctx); + } + + + json->getProperty("access", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->access), ctx); + } + + + json->getProperty("viewDimension", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->viewDimension), ctx); + } + + + json->getProperty("sampleType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampleType), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("immutableSamplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->immutableSamplers), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DescriptorSetLayoutBinding(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayoutBinding", obj, nullptr, _SE(js_new_cc_gfx_DescriptorSetLayoutBinding)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("binding", _SE(js_cc_gfx_DescriptorSetLayoutBinding_binding_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_binding_set)); + cls->defineProperty("descriptorType", _SE(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_descriptorType_set)); + cls->defineProperty("count", _SE(js_cc_gfx_DescriptorSetLayoutBinding_count_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_count_set)); + cls->defineProperty("stageFlags", _SE(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_stageFlags_set)); + cls->defineProperty("access", _SE(js_cc_gfx_DescriptorSetLayoutBinding_access_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_access_set)); + cls->defineProperty("viewDimension", _SE(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_viewDimension_set)); + cls->defineProperty("sampleType", _SE(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_sampleType_set)); + cls->defineProperty("format", _SE(js_cc_gfx_DescriptorSetLayoutBinding_format_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_format_set)); + cls->defineProperty("immutableSamplers", _SE(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_get), _SE(js_cc_gfx_DescriptorSetLayoutBinding_immutableSamplers_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DescriptorSetLayoutBinding_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetLayoutBinding)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetLayoutBinding_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetLayoutBinding_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetLayoutInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetLayoutInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutInfo) + +static bool js_cc_gfx_DescriptorSetLayoutInfo_bindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutInfo *arg1 = (cc::gfx::DescriptorSetLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetLayoutInfo_bindings_set) + +static bool js_cc_gfx_DescriptorSetLayoutInfo_bindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayoutInfo *arg1 = (cc::gfx::DescriptorSetLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindings, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindings, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetLayoutInfo_bindings_get) + +static bool js_cc_gfx_DescriptorSetLayoutInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayoutInfo *arg1 = (cc::gfx::DescriptorSetLayoutInfo *) NULL ; + cc::gfx::DescriptorSetLayoutInfo *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutInfo temp2 ; + cc::gfx::DescriptorSetLayoutInfo *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(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::gfx::DescriptorSetLayoutInfo *) &(arg1)->copy((cc::gfx::DescriptorSetLayoutInfo 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_gfx_DescriptorSetLayoutInfo_copy) + +static bool js_new_cc_gfx_DescriptorSetLayoutInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DescriptorSetLayoutInfo *result; + result = (cc::gfx::DescriptorSetLayoutInfo *)new cc::gfx::DescriptorSetLayoutInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DescriptorSetLayoutInfo, __jsb_cc_gfx_DescriptorSetLayoutInfo_class, js_delete_cc_gfx_DescriptorSetLayoutInfo) + +static bool js_delete_cc_gfx_DescriptorSetLayoutInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayoutInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindings), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DescriptorSetLayoutInfo(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayoutInfo", obj, nullptr, _SE(js_new_cc_gfx_DescriptorSetLayoutInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindings", _SE(js_cc_gfx_DescriptorSetLayoutInfo_bindings_get), _SE(js_cc_gfx_DescriptorSetLayoutInfo_bindings_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DescriptorSetLayoutInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetLayoutInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetLayoutInfo_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetLayoutInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetInfo_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetInfo) + +static bool js_cc_gfx_DescriptorSetInfo_layout_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetInfo *arg1 = (cc::gfx::DescriptorSetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->layout, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DescriptorSetInfo_layout_set) + +static bool js_cc_gfx_DescriptorSetInfo_layout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetInfo *arg1 = (cc::gfx::DescriptorSetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->layout, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->layout, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DescriptorSetInfo_layout_get) + +static bool js_cc_gfx_DescriptorSetInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetInfo *arg1 = (cc::gfx::DescriptorSetInfo *) NULL ; + cc::gfx::DescriptorSetInfo *arg2 = 0 ; + cc::gfx::DescriptorSetInfo temp2 ; + cc::gfx::DescriptorSetInfo *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(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::gfx::DescriptorSetInfo *) &(arg1)->copy((cc::gfx::DescriptorSetInfo 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_gfx_DescriptorSetInfo_copy) + +static bool js_new_cc_gfx_DescriptorSetInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DescriptorSetInfo *result; + result = (cc::gfx::DescriptorSetInfo *)new cc::gfx::DescriptorSetInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DescriptorSetInfo, __jsb_cc_gfx_DescriptorSetInfo_class, js_delete_cc_gfx_DescriptorSetInfo) + +static bool js_delete_cc_gfx_DescriptorSetInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("layout", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->layout), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DescriptorSetInfo(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetInfo", obj, nullptr, _SE(js_new_cc_gfx_DescriptorSetInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("layout", _SE(js_cc_gfx_DescriptorSetInfo_layout_get), _SE(js_cc_gfx_DescriptorSetInfo_layout_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DescriptorSetInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetInfo_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineLayoutInfo_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineLayoutInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayoutInfo) + +static bool js_cc_gfx_PipelineLayoutInfo_setLayouts_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayoutInfo *arg1 = (cc::gfx::PipelineLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->setLayouts, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineLayoutInfo_setLayouts_set) + +static bool js_cc_gfx_PipelineLayoutInfo_setLayouts_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineLayoutInfo *arg1 = (cc::gfx::PipelineLayoutInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->setLayouts, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->setLayouts, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineLayoutInfo_setLayouts_get) + +static bool js_cc_gfx_PipelineLayoutInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayoutInfo *arg1 = (cc::gfx::PipelineLayoutInfo *) NULL ; + cc::gfx::PipelineLayoutInfo *arg2 = 0 ; + cc::gfx::PipelineLayoutInfo temp2 ; + cc::gfx::PipelineLayoutInfo *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(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::gfx::PipelineLayoutInfo *) &(arg1)->copy((cc::gfx::PipelineLayoutInfo 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_gfx_PipelineLayoutInfo_copy) + +static bool js_new_cc_gfx_PipelineLayoutInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::PipelineLayoutInfo *result; + result = (cc::gfx::PipelineLayoutInfo *)new cc::gfx::PipelineLayoutInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_PipelineLayoutInfo, __jsb_cc_gfx_PipelineLayoutInfo_class, js_delete_cc_gfx_PipelineLayoutInfo) + +static bool js_delete_cc_gfx_PipelineLayoutInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayoutInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineLayoutInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("setLayouts", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->setLayouts), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_PipelineLayoutInfo(se::Object* obj) { + auto* cls = se::Class::create("PipelineLayoutInfo", obj, nullptr, _SE(js_new_cc_gfx_PipelineLayoutInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("setLayouts", _SE(js_cc_gfx_PipelineLayoutInfo_setLayouts_get), _SE(js_cc_gfx_PipelineLayoutInfo_setLayouts_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_PipelineLayoutInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineLayoutInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineLayoutInfo_proto = cls->getProto(); + __jsb_cc_gfx_PipelineLayoutInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_InputState_class = nullptr; +se::Object* __jsb_cc_gfx_InputState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_InputState) + +static bool js_cc_gfx_InputState_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputState *arg1 = (cc::gfx::InputState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputState_attributes_set) + +static bool js_cc_gfx_InputState_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputState *arg1 = (cc::gfx::InputState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputState_attributes_get) + +static bool js_cc_gfx_InputState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputState *arg1 = (cc::gfx::InputState *) NULL ; + cc::gfx::InputState *arg2 = 0 ; + cc::gfx::InputState temp2 ; + cc::gfx::InputState *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(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::gfx::InputState *) &(arg1)->copy((cc::gfx::InputState 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_gfx_InputState_copy) + +static bool js_new_cc_gfx_InputState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::InputState *result; + result = (cc::gfx::InputState *)new cc::gfx::InputState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_InputState, __jsb_cc_gfx_InputState_class, js_delete_cc_gfx_InputState) + +static bool js_delete_cc_gfx_InputState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_InputState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_InputState(se::Object* obj) { + auto* cls = se::Class::create("InputState", obj, nullptr, _SE(js_new_cc_gfx_InputState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("attributes", _SE(js_cc_gfx_InputState_attributes_get), _SE(js_cc_gfx_InputState_attributes_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_InputState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_InputState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_InputState_proto = cls->getProto(); + __jsb_cc_gfx_InputState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_RasterizerState_class = nullptr; +se::Object* __jsb_cc_gfx_RasterizerState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_RasterizerState) + +static bool js_cc_gfx_RasterizerState_isDiscard_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDiscard, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isDiscard_set) + +static bool js_cc_gfx_RasterizerState_isDiscard_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDiscard, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isDiscard_get) + +static bool js_cc_gfx_RasterizerState_polygonMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->polygonMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_polygonMode_set) + +static bool js_cc_gfx_RasterizerState_polygonMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->polygonMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->polygonMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_polygonMode_get) + +static bool js_cc_gfx_RasterizerState_shadeModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shadeModel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_shadeModel_set) + +static bool js_cc_gfx_RasterizerState_shadeModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shadeModel, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shadeModel, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_shadeModel_get) + +static bool js_cc_gfx_RasterizerState_cullMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cullMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_cullMode_set) + +static bool js_cc_gfx_RasterizerState_cullMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cullMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cullMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_cullMode_get) + +static bool js_cc_gfx_RasterizerState_isFrontFaceCCW_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isFrontFaceCCW, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isFrontFaceCCW_set) + +static bool js_cc_gfx_RasterizerState_isFrontFaceCCW_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isFrontFaceCCW, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isFrontFaceCCW_get) + +static bool js_cc_gfx_RasterizerState_depthBiasEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasEnabled, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBiasEnabled_set) + +static bool js_cc_gfx_RasterizerState_depthBiasEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasEnabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBiasEnabled_get) + +static bool js_cc_gfx_RasterizerState_depthBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBias, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBias_set) + +static bool js_cc_gfx_RasterizerState_depthBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBias, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBias_get) + +static bool js_cc_gfx_RasterizerState_depthBiasClamp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasClamp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBiasClamp_set) + +static bool js_cc_gfx_RasterizerState_depthBiasClamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasClamp, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBiasClamp_get) + +static bool js_cc_gfx_RasterizerState_depthBiasSlop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasSlop, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_depthBiasSlop_set) + +static bool js_cc_gfx_RasterizerState_depthBiasSlop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasSlop, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_depthBiasSlop_get) + +static bool js_cc_gfx_RasterizerState_isDepthClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDepthClip, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isDepthClip_set) + +static bool js_cc_gfx_RasterizerState_isDepthClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDepthClip, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isDepthClip_get) + +static bool js_cc_gfx_RasterizerState_isMultisample_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isMultisample, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_isMultisample_set) + +static bool js_cc_gfx_RasterizerState_isMultisample_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isMultisample, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_isMultisample_get) + +static bool js_cc_gfx_RasterizerState_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_RasterizerState_lineWidth_set) + +static bool js_cc_gfx_RasterizerState_lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lineWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_RasterizerState_lineWidth_get) + +static bool js_cc_gfx_RasterizerState_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_RasterizerState_reset) + +static bool js_cc_gfx_RasterizerState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RasterizerState *arg1 = (cc::gfx::RasterizerState *) NULL ; + cc::gfx::RasterizerState *arg2 = 0 ; + cc::gfx::RasterizerState temp2 ; + cc::gfx::RasterizerState *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(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::gfx::RasterizerState *) &(arg1)->copy((cc::gfx::RasterizerState 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_gfx_RasterizerState_copy) + +static bool js_new_cc_gfx_RasterizerState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::RasterizerState *result; + result = (cc::gfx::RasterizerState *)new cc::gfx::RasterizerState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_RasterizerState, __jsb_cc_gfx_RasterizerState_class, js_delete_cc_gfx_RasterizerState) + +static bool js_delete_cc_gfx_RasterizerState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_RasterizerState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RasterizerState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isDiscard", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDiscard), ctx); + } + + + json->getProperty("polygonMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->polygonMode), ctx); + } + + + json->getProperty("shadeModel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shadeModel), ctx); + } + + + json->getProperty("cullMode", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cullMode), ctx); + } + + + json->getProperty("isFrontFaceCCW", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isFrontFaceCCW), ctx); + } + + + json->getProperty("depthBiasEnabled", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasEnabled), ctx); + } + + + json->getProperty("depthBias", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBias), ctx); + } + + + json->getProperty("depthBiasClamp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasClamp), ctx); + } + + + json->getProperty("depthBiasSlop", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasSlop), ctx); + } + + + json->getProperty("isDepthClip", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDepthClip), ctx); + } + + + json->getProperty("isMultisample", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isMultisample), ctx); + } + + + json->getProperty("lineWidth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lineWidth), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_RasterizerState(se::Object* obj) { + auto* cls = se::Class::create("RasterizerState", obj, nullptr, _SE(js_new_cc_gfx_RasterizerState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isDiscard", _SE(js_cc_gfx_RasterizerState_isDiscard_get), _SE(js_cc_gfx_RasterizerState_isDiscard_set)); + cls->defineProperty("polygonMode", _SE(js_cc_gfx_RasterizerState_polygonMode_get), _SE(js_cc_gfx_RasterizerState_polygonMode_set)); + cls->defineProperty("shadeModel", _SE(js_cc_gfx_RasterizerState_shadeModel_get), _SE(js_cc_gfx_RasterizerState_shadeModel_set)); + cls->defineProperty("cullMode", _SE(js_cc_gfx_RasterizerState_cullMode_get), _SE(js_cc_gfx_RasterizerState_cullMode_set)); + cls->defineProperty("isFrontFaceCCW", _SE(js_cc_gfx_RasterizerState_isFrontFaceCCW_get), _SE(js_cc_gfx_RasterizerState_isFrontFaceCCW_set)); + cls->defineProperty("depthBiasEnabled", _SE(js_cc_gfx_RasterizerState_depthBiasEnabled_get), _SE(js_cc_gfx_RasterizerState_depthBiasEnabled_set)); + cls->defineProperty("depthBias", _SE(js_cc_gfx_RasterizerState_depthBias_get), _SE(js_cc_gfx_RasterizerState_depthBias_set)); + cls->defineProperty("depthBiasClamp", _SE(js_cc_gfx_RasterizerState_depthBiasClamp_get), _SE(js_cc_gfx_RasterizerState_depthBiasClamp_set)); + cls->defineProperty("depthBiasSlop", _SE(js_cc_gfx_RasterizerState_depthBiasSlop_get), _SE(js_cc_gfx_RasterizerState_depthBiasSlop_set)); + cls->defineProperty("isDepthClip", _SE(js_cc_gfx_RasterizerState_isDepthClip_get), _SE(js_cc_gfx_RasterizerState_isDepthClip_set)); + cls->defineProperty("isMultisample", _SE(js_cc_gfx_RasterizerState_isMultisample_get), _SE(js_cc_gfx_RasterizerState_isMultisample_set)); + cls->defineProperty("lineWidth", _SE(js_cc_gfx_RasterizerState_lineWidth_get), _SE(js_cc_gfx_RasterizerState_lineWidth_set)); + + cls->defineFunction("reset", _SE(js_cc_gfx_RasterizerState_reset)); + cls->defineFunction("copy", _SE(js_cc_gfx_RasterizerState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_RasterizerState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_RasterizerState_proto = cls->getProto(); + __jsb_cc_gfx_RasterizerState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DepthStencilState_class = nullptr; +se::Object* __jsb_cc_gfx_DepthStencilState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilState) + +static bool js_cc_gfx_DepthStencilState_depthTest_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthTest, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_depthTest_set) + +static bool js_cc_gfx_DepthStencilState_depthTest_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthTest, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_depthTest_get) + +static bool js_cc_gfx_DepthStencilState_depthWrite_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthWrite, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_depthWrite_set) + +static bool js_cc_gfx_DepthStencilState_depthWrite_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthWrite, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_depthWrite_get) + +static bool js_cc_gfx_DepthStencilState_depthFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_depthFunc_set) + +static bool js_cc_gfx_DepthStencilState_depthFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_depthFunc_get) + +static bool js_cc_gfx_DepthStencilState_stencilTestFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilTestFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilTestFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilTestFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilFuncFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFuncFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilFuncFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFuncFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilReadMaskFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilReadMaskFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFailOpFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFailOpFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilZFailOpFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilZFailOpFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilPassOpFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilPassOpFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilRefFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilRefFront_set) + +static bool js_cc_gfx_DepthStencilState_stencilRefFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefFront, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilRefFront_get) + +static bool js_cc_gfx_DepthStencilState_stencilTestBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilTestBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilTestBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilTestBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilTestBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilTestBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilFuncBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFuncBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFuncBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilFuncBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFuncBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFuncBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFuncBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilReadMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilReadMaskBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilReadMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilReadMaskBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilReadMaskBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilWriteMaskBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilWriteMaskBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilWriteMaskBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilFailOpBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilFailOpBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilZFailOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilZFailOpBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilZFailOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilZFailOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilZFailOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilZFailOpBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilPassOpBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilPassOpBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilPassOpBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilPassOpBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilPassOpBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilPassOpBack_get) + +static bool js_cc_gfx_DepthStencilState_stencilRefBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilRefBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DepthStencilState_stencilRefBack_set) + +static bool js_cc_gfx_DepthStencilState_stencilRefBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilRefBack, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DepthStencilState_stencilRefBack_get) + +static bool js_cc_gfx_DepthStencilState_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DepthStencilState_reset) + +static bool js_cc_gfx_DepthStencilState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DepthStencilState *arg1 = (cc::gfx::DepthStencilState *) NULL ; + cc::gfx::DepthStencilState *arg2 = 0 ; + cc::gfx::DepthStencilState temp2 ; + cc::gfx::DepthStencilState *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(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::gfx::DepthStencilState *) &(arg1)->copy((cc::gfx::DepthStencilState 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_gfx_DepthStencilState_copy) + +static bool js_new_cc_gfx_DepthStencilState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DepthStencilState *result; + result = (cc::gfx::DepthStencilState *)new cc::gfx::DepthStencilState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DepthStencilState, __jsb_cc_gfx_DepthStencilState_class, js_delete_cc_gfx_DepthStencilState) + +static bool js_delete_cc_gfx_DepthStencilState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DepthStencilState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("depthTest", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthTest), ctx); + } + + + json->getProperty("depthWrite", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthWrite), ctx); + } + + + json->getProperty("depthFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthFunc), ctx); + } + + + json->getProperty("stencilTestFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestFront), ctx); + } + + + json->getProperty("stencilFuncFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncFront), ctx); + } + + + json->getProperty("stencilReadMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskFront), ctx); + } + + + json->getProperty("stencilWriteMaskFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskFront), ctx); + } + + + json->getProperty("stencilFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpFront), ctx); + } + + + json->getProperty("stencilZFailOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpFront), ctx); + } + + + json->getProperty("stencilPassOpFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpFront), ctx); + } + + + json->getProperty("stencilRefFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefFront), ctx); + } + + + json->getProperty("stencilTestBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilTestBack), ctx); + } + + + json->getProperty("stencilFuncBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFuncBack), ctx); + } + + + json->getProperty("stencilReadMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilReadMaskBack), ctx); + } + + + json->getProperty("stencilWriteMaskBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilWriteMaskBack), ctx); + } + + + json->getProperty("stencilFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilFailOpBack), ctx); + } + + + json->getProperty("stencilZFailOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilZFailOpBack), ctx); + } + + + json->getProperty("stencilPassOpBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilPassOpBack), ctx); + } + + + json->getProperty("stencilRefBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilRefBack), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DepthStencilState(se::Object* obj) { + auto* cls = se::Class::create("DepthStencilState", obj, nullptr, _SE(js_new_cc_gfx_DepthStencilState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("depthTest", _SE(js_cc_gfx_DepthStencilState_depthTest_get), _SE(js_cc_gfx_DepthStencilState_depthTest_set)); + cls->defineProperty("depthWrite", _SE(js_cc_gfx_DepthStencilState_depthWrite_get), _SE(js_cc_gfx_DepthStencilState_depthWrite_set)); + cls->defineProperty("depthFunc", _SE(js_cc_gfx_DepthStencilState_depthFunc_get), _SE(js_cc_gfx_DepthStencilState_depthFunc_set)); + cls->defineProperty("stencilTestFront", _SE(js_cc_gfx_DepthStencilState_stencilTestFront_get), _SE(js_cc_gfx_DepthStencilState_stencilTestFront_set)); + cls->defineProperty("stencilFuncFront", _SE(js_cc_gfx_DepthStencilState_stencilFuncFront_get), _SE(js_cc_gfx_DepthStencilState_stencilFuncFront_set)); + cls->defineProperty("stencilReadMaskFront", _SE(js_cc_gfx_DepthStencilState_stencilReadMaskFront_get), _SE(js_cc_gfx_DepthStencilState_stencilReadMaskFront_set)); + cls->defineProperty("stencilWriteMaskFront", _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_get), _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskFront_set)); + cls->defineProperty("stencilFailOpFront", _SE(js_cc_gfx_DepthStencilState_stencilFailOpFront_get), _SE(js_cc_gfx_DepthStencilState_stencilFailOpFront_set)); + cls->defineProperty("stencilZFailOpFront", _SE(js_cc_gfx_DepthStencilState_stencilZFailOpFront_get), _SE(js_cc_gfx_DepthStencilState_stencilZFailOpFront_set)); + cls->defineProperty("stencilPassOpFront", _SE(js_cc_gfx_DepthStencilState_stencilPassOpFront_get), _SE(js_cc_gfx_DepthStencilState_stencilPassOpFront_set)); + cls->defineProperty("stencilRefFront", _SE(js_cc_gfx_DepthStencilState_stencilRefFront_get), _SE(js_cc_gfx_DepthStencilState_stencilRefFront_set)); + cls->defineProperty("stencilTestBack", _SE(js_cc_gfx_DepthStencilState_stencilTestBack_get), _SE(js_cc_gfx_DepthStencilState_stencilTestBack_set)); + cls->defineProperty("stencilFuncBack", _SE(js_cc_gfx_DepthStencilState_stencilFuncBack_get), _SE(js_cc_gfx_DepthStencilState_stencilFuncBack_set)); + cls->defineProperty("stencilReadMaskBack", _SE(js_cc_gfx_DepthStencilState_stencilReadMaskBack_get), _SE(js_cc_gfx_DepthStencilState_stencilReadMaskBack_set)); + cls->defineProperty("stencilWriteMaskBack", _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_get), _SE(js_cc_gfx_DepthStencilState_stencilWriteMaskBack_set)); + cls->defineProperty("stencilFailOpBack", _SE(js_cc_gfx_DepthStencilState_stencilFailOpBack_get), _SE(js_cc_gfx_DepthStencilState_stencilFailOpBack_set)); + cls->defineProperty("stencilZFailOpBack", _SE(js_cc_gfx_DepthStencilState_stencilZFailOpBack_get), _SE(js_cc_gfx_DepthStencilState_stencilZFailOpBack_set)); + cls->defineProperty("stencilPassOpBack", _SE(js_cc_gfx_DepthStencilState_stencilPassOpBack_get), _SE(js_cc_gfx_DepthStencilState_stencilPassOpBack_set)); + cls->defineProperty("stencilRefBack", _SE(js_cc_gfx_DepthStencilState_stencilRefBack_get), _SE(js_cc_gfx_DepthStencilState_stencilRefBack_set)); + + cls->defineFunction("reset", _SE(js_cc_gfx_DepthStencilState_reset)); + cls->defineFunction("copy", _SE(js_cc_gfx_DepthStencilState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DepthStencilState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DepthStencilState_proto = cls->getProto(); + __jsb_cc_gfx_DepthStencilState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BlendTarget_class = nullptr; +se::Object* __jsb_cc_gfx_BlendTarget_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BlendTarget) + +static bool js_cc_gfx_BlendTarget_blend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blend_set) + +static bool js_cc_gfx_BlendTarget_blend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blend, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blend_get) + +static bool js_cc_gfx_BlendTarget_blendSrc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendSrc_set) + +static bool js_cc_gfx_BlendTarget_blendSrc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendSrc_get) + +static bool js_cc_gfx_BlendTarget_blendDst_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDst, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendDst_set) + +static bool js_cc_gfx_BlendTarget_blendDst_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDst, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDst, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendDst_get) + +static bool js_cc_gfx_BlendTarget_blendEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendEq_set) + +static bool js_cc_gfx_BlendTarget_blendEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendEq_get) + +static bool js_cc_gfx_BlendTarget_blendSrcAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendSrcAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendSrcAlpha_set) + +static bool js_cc_gfx_BlendTarget_blendSrcAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendSrcAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendSrcAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendSrcAlpha_get) + +static bool js_cc_gfx_BlendTarget_blendDstAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendDstAlpha, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendDstAlpha_set) + +static bool js_cc_gfx_BlendTarget_blendDstAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendDstAlpha, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendDstAlpha, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendDstAlpha_get) + +static bool js_cc_gfx_BlendTarget_blendAlphaEq_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendAlphaEq, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendAlphaEq_set) + +static bool js_cc_gfx_BlendTarget_blendAlphaEq_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendAlphaEq, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendAlphaEq, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendAlphaEq_get) + +static bool js_cc_gfx_BlendTarget_blendColorMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColorMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendTarget_blendColorMask_set) + +static bool js_cc_gfx_BlendTarget_blendColorMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColorMask, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColorMask, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendTarget_blendColorMask_get) + +static bool js_cc_gfx_BlendTarget_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendTarget_reset) + +static bool js_cc_gfx_BlendTarget_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendTarget *arg1 = (cc::gfx::BlendTarget *) NULL ; + cc::gfx::BlendTarget *arg2 = 0 ; + cc::gfx::BlendTarget temp2 ; + cc::gfx::BlendTarget *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(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::gfx::BlendTarget *) &(arg1)->copy((cc::gfx::BlendTarget 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_gfx_BlendTarget_copy) + +static bool js_new_cc_gfx_BlendTarget(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BlendTarget *result; + result = (cc::gfx::BlendTarget *)new cc::gfx::BlendTarget(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BlendTarget, __jsb_cc_gfx_BlendTarget_class, js_delete_cc_gfx_BlendTarget) + +static bool js_delete_cc_gfx_BlendTarget(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BlendTarget) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendTarget * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("blend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blend), ctx); + } + + + json->getProperty("blendSrc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrc), ctx); + } + + + json->getProperty("blendDst", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDst), ctx); + } + + + json->getProperty("blendEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendEq), ctx); + } + + + json->getProperty("blendSrcAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendSrcAlpha), ctx); + } + + + json->getProperty("blendDstAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendDstAlpha), ctx); + } + + + json->getProperty("blendAlphaEq", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendAlphaEq), ctx); + } + + + json->getProperty("blendColorMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColorMask), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BlendTarget(se::Object* obj) { + auto* cls = se::Class::create("BlendTarget", obj, nullptr, _SE(js_new_cc_gfx_BlendTarget)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("blend", _SE(js_cc_gfx_BlendTarget_blend_get), _SE(js_cc_gfx_BlendTarget_blend_set)); + cls->defineProperty("blendSrc", _SE(js_cc_gfx_BlendTarget_blendSrc_get), _SE(js_cc_gfx_BlendTarget_blendSrc_set)); + cls->defineProperty("blendDst", _SE(js_cc_gfx_BlendTarget_blendDst_get), _SE(js_cc_gfx_BlendTarget_blendDst_set)); + cls->defineProperty("blendEq", _SE(js_cc_gfx_BlendTarget_blendEq_get), _SE(js_cc_gfx_BlendTarget_blendEq_set)); + cls->defineProperty("blendSrcAlpha", _SE(js_cc_gfx_BlendTarget_blendSrcAlpha_get), _SE(js_cc_gfx_BlendTarget_blendSrcAlpha_set)); + cls->defineProperty("blendDstAlpha", _SE(js_cc_gfx_BlendTarget_blendDstAlpha_get), _SE(js_cc_gfx_BlendTarget_blendDstAlpha_set)); + cls->defineProperty("blendAlphaEq", _SE(js_cc_gfx_BlendTarget_blendAlphaEq_get), _SE(js_cc_gfx_BlendTarget_blendAlphaEq_set)); + cls->defineProperty("blendColorMask", _SE(js_cc_gfx_BlendTarget_blendColorMask_get), _SE(js_cc_gfx_BlendTarget_blendColorMask_set)); + + cls->defineFunction("reset", _SE(js_cc_gfx_BlendTarget_reset)); + cls->defineFunction("copy", _SE(js_cc_gfx_BlendTarget_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BlendTarget)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BlendTarget_proto = cls->getProto(); + __jsb_cc_gfx_BlendTarget_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BlendState_class = nullptr; +se::Object* __jsb_cc_gfx_BlendState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BlendState) + +static bool js_cc_gfx_BlendState_isA2C_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isA2C, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_isA2C_set) + +static bool js_cc_gfx_BlendState_isA2C_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isA2C, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_isA2C_get) + +static bool js_cc_gfx_BlendState_isIndepend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isIndepend, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_isIndepend_set) + +static bool js_cc_gfx_BlendState_isIndepend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isIndepend, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_isIndepend_get) + +static bool js_cc_gfx_BlendState_blendColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_blendColor_set) + +static bool js_cc_gfx_BlendState_blendColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_blendColor_get) + +static bool js_cc_gfx_BlendState_targets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targets, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_BlendState_targets_set) + +static bool js_cc_gfx_BlendState_targets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targets, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targets, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_BlendState_targets_get) + +static bool js_cc_gfx_BlendState_setTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + index_t arg2 ; + cc::gfx::BlendTarget *arg3 = 0 ; + cc::gfx::BlendTarget temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTarget(arg2,(cc::gfx::BlendTarget const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendState_setTarget) + +static bool js_cc_gfx_BlendState_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendState_reset) + +static bool js_cc_gfx_BlendState_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_BlendState_destroy) + +static bool js_cc_gfx_BlendState_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BlendState *arg1 = (cc::gfx::BlendState *) NULL ; + cc::gfx::BlendState *arg2 = 0 ; + cc::gfx::BlendState temp2 ; + cc::gfx::BlendState *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(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::gfx::BlendState *) &(arg1)->copy((cc::gfx::BlendState 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_gfx_BlendState_copy) + +static bool js_new_cc_gfx_BlendState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::BlendState *result; + result = (cc::gfx::BlendState *)new cc::gfx::BlendState(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_BlendState, __jsb_cc_gfx_BlendState_class, js_delete_cc_gfx_BlendState) + +static bool js_delete_cc_gfx_BlendState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BlendState) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendState * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isA2C", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isA2C), ctx); + } + + + json->getProperty("isIndepend", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isIndepend), ctx); + } + + + json->getProperty("blendColor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendColor), ctx); + } + + + json->getProperty("targets", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targets), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_BlendState(se::Object* obj) { + auto* cls = se::Class::create("BlendState", obj, nullptr, _SE(js_new_cc_gfx_BlendState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isA2C", _SE(js_cc_gfx_BlendState_isA2C_get), _SE(js_cc_gfx_BlendState_isA2C_set)); + cls->defineProperty("isIndepend", _SE(js_cc_gfx_BlendState_isIndepend_get), _SE(js_cc_gfx_BlendState_isIndepend_set)); + cls->defineProperty("blendColor", _SE(js_cc_gfx_BlendState_blendColor_get), _SE(js_cc_gfx_BlendState_blendColor_set)); + cls->defineProperty("targets", _SE(js_cc_gfx_BlendState_targets_get), _SE(js_cc_gfx_BlendState_targets_set)); + + cls->defineFunction("setTarget", _SE(js_cc_gfx_BlendState_setTarget)); + cls->defineFunction("reset", _SE(js_cc_gfx_BlendState_reset)); + cls->defineFunction("destroy", _SE(js_cc_gfx_BlendState_destroy)); + cls->defineFunction("copy", _SE(js_cc_gfx_BlendState_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BlendState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BlendState_proto = cls->getProto(); + __jsb_cc_gfx_BlendState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineStateInfo_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineStateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineStateInfo) + +static bool js_cc_gfx_PipelineStateInfo_shader_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shader, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_shader_set) + +static bool js_cc_gfx_PipelineStateInfo_shader_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shader, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shader, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_shader_get) + +static bool js_cc_gfx_PipelineStateInfo_pipelineLayout_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pipelineLayout, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_pipelineLayout_set) + +static bool js_cc_gfx_PipelineStateInfo_pipelineLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pipelineLayout, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pipelineLayout, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_pipelineLayout_get) + +static bool js_cc_gfx_PipelineStateInfo_renderPass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_renderPass_set) + +static bool js_cc_gfx_PipelineStateInfo_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPass, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderPass, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_renderPass_get) + +static bool js_cc_gfx_PipelineStateInfo_inputState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->inputState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_inputState_set) + +static bool js_cc_gfx_PipelineStateInfo_inputState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->inputState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->inputState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_inputState_get) + +static bool js_cc_gfx_PipelineStateInfo_rasterizerState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rasterizerState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_rasterizerState_set) + +static bool js_cc_gfx_PipelineStateInfo_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rasterizerState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->rasterizerState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_rasterizerState_get) + +static bool js_cc_gfx_PipelineStateInfo_depthStencilState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_depthStencilState_set) + +static bool js_cc_gfx_PipelineStateInfo_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_depthStencilState_get) + +static bool js_cc_gfx_PipelineStateInfo_blendState_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendState, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_blendState_set) + +static bool js_cc_gfx_PipelineStateInfo_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendState, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendState, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_blendState_get) + +static bool js_cc_gfx_PipelineStateInfo_primitive_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->primitive, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_primitive_set) + +static bool js_cc_gfx_PipelineStateInfo_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->primitive, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->primitive, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_primitive_get) + +static bool js_cc_gfx_PipelineStateInfo_dynamicStates_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dynamicStates, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_dynamicStates_set) + +static bool js_cc_gfx_PipelineStateInfo_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dynamicStates, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->dynamicStates, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_dynamicStates_get) + +static bool js_cc_gfx_PipelineStateInfo_bindPoint_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindPoint, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_bindPoint_set) + +static bool js_cc_gfx_PipelineStateInfo_bindPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindPoint, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindPoint, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_bindPoint_get) + +static bool js_cc_gfx_PipelineStateInfo_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_PipelineStateInfo_subpass_set) + +static bool js_cc_gfx_PipelineStateInfo_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_PipelineStateInfo_subpass_get) + +static bool js_cc_gfx_PipelineStateInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineStateInfo *arg1 = (cc::gfx::PipelineStateInfo *) NULL ; + cc::gfx::PipelineStateInfo *arg2 = 0 ; + cc::gfx::PipelineStateInfo temp2 ; + cc::gfx::PipelineStateInfo *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(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::gfx::PipelineStateInfo *) &(arg1)->copy((cc::gfx::PipelineStateInfo 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_gfx_PipelineStateInfo_copy) + +static bool js_new_cc_gfx_PipelineStateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::PipelineStateInfo *result; + result = (cc::gfx::PipelineStateInfo *)new cc::gfx::PipelineStateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_PipelineStateInfo, __jsb_cc_gfx_PipelineStateInfo_class, js_delete_cc_gfx_PipelineStateInfo) + +static bool js_delete_cc_gfx_PipelineStateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineStateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineStateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("shader", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shader), ctx); + } + + + json->getProperty("pipelineLayout", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pipelineLayout), ctx); + } + + + json->getProperty("renderPass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPass), ctx); + } + + + json->getProperty("inputState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->inputState), ctx); + } + + + json->getProperty("rasterizerState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->rasterizerState), ctx); + } + + + json->getProperty("depthStencilState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilState), ctx); + } + + + json->getProperty("blendState", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendState), ctx); + } + + + json->getProperty("primitive", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->primitive), ctx); + } + + + json->getProperty("dynamicStates", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dynamicStates), ctx); + } + + + json->getProperty("bindPoint", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindPoint), ctx); + } + + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_PipelineStateInfo(se::Object* obj) { + auto* cls = se::Class::create("PipelineStateInfo", obj, nullptr, _SE(js_new_cc_gfx_PipelineStateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("shader", _SE(js_cc_gfx_PipelineStateInfo_shader_get), _SE(js_cc_gfx_PipelineStateInfo_shader_set)); + cls->defineProperty("pipelineLayout", _SE(js_cc_gfx_PipelineStateInfo_pipelineLayout_get), _SE(js_cc_gfx_PipelineStateInfo_pipelineLayout_set)); + cls->defineProperty("renderPass", _SE(js_cc_gfx_PipelineStateInfo_renderPass_get), _SE(js_cc_gfx_PipelineStateInfo_renderPass_set)); + cls->defineProperty("inputState", _SE(js_cc_gfx_PipelineStateInfo_inputState_get), _SE(js_cc_gfx_PipelineStateInfo_inputState_set)); + cls->defineProperty("rasterizerState", _SE(js_cc_gfx_PipelineStateInfo_rasterizerState_get), _SE(js_cc_gfx_PipelineStateInfo_rasterizerState_set)); + cls->defineProperty("depthStencilState", _SE(js_cc_gfx_PipelineStateInfo_depthStencilState_get), _SE(js_cc_gfx_PipelineStateInfo_depthStencilState_set)); + cls->defineProperty("blendState", _SE(js_cc_gfx_PipelineStateInfo_blendState_get), _SE(js_cc_gfx_PipelineStateInfo_blendState_set)); + cls->defineProperty("primitive", _SE(js_cc_gfx_PipelineStateInfo_primitive_get), _SE(js_cc_gfx_PipelineStateInfo_primitive_set)); + cls->defineProperty("dynamicStates", _SE(js_cc_gfx_PipelineStateInfo_dynamicStates_get), _SE(js_cc_gfx_PipelineStateInfo_dynamicStates_set)); + cls->defineProperty("bindPoint", _SE(js_cc_gfx_PipelineStateInfo_bindPoint_get), _SE(js_cc_gfx_PipelineStateInfo_bindPoint_set)); + cls->defineProperty("subpass", _SE(js_cc_gfx_PipelineStateInfo_subpass_get), _SE(js_cc_gfx_PipelineStateInfo_subpass_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_PipelineStateInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineStateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineStateInfo_proto = cls->getProto(); + __jsb_cc_gfx_PipelineStateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_CommandBufferInfo_class = nullptr; +se::Object* __jsb_cc_gfx_CommandBufferInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_CommandBufferInfo) + +static bool js_cc_gfx_CommandBufferInfo_queue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->queue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_CommandBufferInfo_queue_set) + +static bool js_cc_gfx_CommandBufferInfo_queue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->queue, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->queue, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBufferInfo_queue_get) + +static bool js_cc_gfx_CommandBufferInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_CommandBufferInfo_type_set) + +static bool js_cc_gfx_CommandBufferInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBufferInfo_type_get) + +static bool js_cc_gfx_CommandBufferInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBufferInfo *arg1 = (cc::gfx::CommandBufferInfo *) NULL ; + cc::gfx::CommandBufferInfo *arg2 = 0 ; + cc::gfx::CommandBufferInfo temp2 ; + cc::gfx::CommandBufferInfo *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(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::gfx::CommandBufferInfo *) &(arg1)->copy((cc::gfx::CommandBufferInfo 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_gfx_CommandBufferInfo_copy) + +static bool js_new_cc_gfx_CommandBufferInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::CommandBufferInfo *result; + result = (cc::gfx::CommandBufferInfo *)new cc::gfx::CommandBufferInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_CommandBufferInfo, __jsb_cc_gfx_CommandBufferInfo_class, js_delete_cc_gfx_CommandBufferInfo) + +static bool js_delete_cc_gfx_CommandBufferInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_CommandBufferInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::CommandBufferInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("queue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->queue), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_CommandBufferInfo(se::Object* obj) { + auto* cls = se::Class::create("CommandBufferInfo", obj, nullptr, _SE(js_new_cc_gfx_CommandBufferInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("queue", _SE(js_cc_gfx_CommandBufferInfo_queue_get), _SE(js_cc_gfx_CommandBufferInfo_queue_set)); + cls->defineProperty("type", _SE(js_cc_gfx_CommandBufferInfo_type_get), _SE(js_cc_gfx_CommandBufferInfo_type_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_CommandBufferInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_CommandBufferInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_CommandBufferInfo_proto = cls->getProto(); + __jsb_cc_gfx_CommandBufferInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_QueueInfo_class = nullptr; +se::Object* __jsb_cc_gfx_QueueInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_QueueInfo) + +static bool js_cc_gfx_QueueInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueueInfo *arg1 = (cc::gfx::QueueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueueInfo_type_set) + +static bool js_cc_gfx_QueueInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueueInfo *arg1 = (cc::gfx::QueueInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueueInfo_type_get) + +static bool js_cc_gfx_QueueInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueueInfo *arg1 = (cc::gfx::QueueInfo *) NULL ; + cc::gfx::QueueInfo *arg2 = 0 ; + cc::gfx::QueueInfo temp2 ; + cc::gfx::QueueInfo *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(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::gfx::QueueInfo *) &(arg1)->copy((cc::gfx::QueueInfo 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_gfx_QueueInfo_copy) + +static bool js_new_cc_gfx_QueueInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::QueueInfo *result; + result = (cc::gfx::QueueInfo *)new cc::gfx::QueueInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_QueueInfo, __jsb_cc_gfx_QueueInfo_class, js_delete_cc_gfx_QueueInfo) + +static bool js_delete_cc_gfx_QueueInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_QueueInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueueInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_QueueInfo(se::Object* obj) { + auto* cls = se::Class::create("QueueInfo", obj, nullptr, _SE(js_new_cc_gfx_QueueInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_QueueInfo_type_get), _SE(js_cc_gfx_QueueInfo_type_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_QueueInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_QueueInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_QueueInfo_proto = cls->getProto(); + __jsb_cc_gfx_QueueInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_QueryPoolInfo_class = nullptr; +se::Object* __jsb_cc_gfx_QueryPoolInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_QueryPoolInfo) + +static bool js_cc_gfx_QueryPoolInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueryPoolInfo_type_set) + +static bool js_cc_gfx_QueryPoolInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueryPoolInfo_type_get) + +static bool js_cc_gfx_QueryPoolInfo_maxQueryObjects_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->maxQueryObjects, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueryPoolInfo_maxQueryObjects_set) + +static bool js_cc_gfx_QueryPoolInfo_maxQueryObjects_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->maxQueryObjects, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueryPoolInfo_maxQueryObjects_get) + +static bool js_cc_gfx_QueryPoolInfo_forceWait_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->forceWait); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_QueryPoolInfo_forceWait_set) + +static bool js_cc_gfx_QueryPoolInfo_forceWait_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->forceWait, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_QueryPoolInfo_forceWait_get) + +static bool js_cc_gfx_QueryPoolInfo_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPoolInfo *arg1 = (cc::gfx::QueryPoolInfo *) NULL ; + cc::gfx::QueryPoolInfo *arg2 = 0 ; + cc::gfx::QueryPoolInfo temp2 ; + cc::gfx::QueryPoolInfo *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(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::gfx::QueryPoolInfo *) &(arg1)->copy((cc::gfx::QueryPoolInfo 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_gfx_QueryPoolInfo_copy) + +static bool js_new_cc_gfx_QueryPoolInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::QueryPoolInfo *result; + result = (cc::gfx::QueryPoolInfo *)new cc::gfx::QueryPoolInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_QueryPoolInfo, __jsb_cc_gfx_QueryPoolInfo_class, js_delete_cc_gfx_QueryPoolInfo) + +static bool js_delete_cc_gfx_QueryPoolInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_QueryPoolInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueryPoolInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("maxQueryObjects", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->maxQueryObjects), ctx); + } + + + json->getProperty("forceWait", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->forceWait), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_QueryPoolInfo(se::Object* obj) { + auto* cls = se::Class::create("QueryPoolInfo", obj, nullptr, _SE(js_new_cc_gfx_QueryPoolInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_QueryPoolInfo_type_get), _SE(js_cc_gfx_QueryPoolInfo_type_set)); + cls->defineProperty("maxQueryObjects", _SE(js_cc_gfx_QueryPoolInfo_maxQueryObjects_get), _SE(js_cc_gfx_QueryPoolInfo_maxQueryObjects_set)); + cls->defineProperty("forceWait", _SE(js_cc_gfx_QueryPoolInfo_forceWait_get), _SE(js_cc_gfx_QueryPoolInfo_forceWait_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_QueryPoolInfo_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_QueryPoolInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_QueryPoolInfo_proto = cls->getProto(); + __jsb_cc_gfx_QueryPoolInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_FormatInfo_class = nullptr; +se::Object* __jsb_cc_gfx_FormatInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_FormatInfo) + +static bool js_cc_gfx_FormatInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_name_set) + +static bool js_cc_gfx_FormatInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_name_get) + +static bool js_cc_gfx_FormatInfo_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_size_set) + +static bool js_cc_gfx_FormatInfo_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->size, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_size_get) + +static bool js_cc_gfx_FormatInfo_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_count_set) + +static bool js_cc_gfx_FormatInfo_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_count_get) + +static bool js_cc_gfx_FormatInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_type_set) + +static bool js_cc_gfx_FormatInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_type_get) + +static bool js_cc_gfx_FormatInfo_hasAlpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hasAlpha); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_hasAlpha_set) + +static bool js_cc_gfx_FormatInfo_hasAlpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hasAlpha, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_hasAlpha_get) + +static bool js_cc_gfx_FormatInfo_hasDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hasDepth); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_hasDepth_set) + +static bool js_cc_gfx_FormatInfo_hasDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hasDepth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_hasDepth_get) + +static bool js_cc_gfx_FormatInfo_hasStencil_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hasStencil); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_hasStencil_set) + +static bool js_cc_gfx_FormatInfo_hasStencil_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hasStencil, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_hasStencil_get) + +static bool js_cc_gfx_FormatInfo_isCompressed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isCompressed); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_FormatInfo_isCompressed_set) + +static bool js_cc_gfx_FormatInfo_isCompressed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::FormatInfo *arg1 = (cc::gfx::FormatInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isCompressed, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_FormatInfo_isCompressed_get) + +static bool js_new_cc_gfx_FormatInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::FormatInfo *result; + result = (cc::gfx::FormatInfo *)new cc::gfx::FormatInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_FormatInfo, __jsb_cc_gfx_FormatInfo_class, js_delete_cc_gfx_FormatInfo) + +static bool js_delete_cc_gfx_FormatInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_FormatInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FormatInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("size", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->size), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("hasAlpha", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hasAlpha), ctx); + } + + + json->getProperty("hasDepth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hasDepth), ctx); + } + + + json->getProperty("hasStencil", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hasStencil), ctx); + } + + + json->getProperty("isCompressed", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isCompressed), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_FormatInfo(se::Object* obj) { + auto* cls = se::Class::create("FormatInfo", obj, nullptr, _SE(js_new_cc_gfx_FormatInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_gfx_FormatInfo_name_get), _SE(js_cc_gfx_FormatInfo_name_set)); + cls->defineProperty("size", _SE(js_cc_gfx_FormatInfo_size_get), _SE(js_cc_gfx_FormatInfo_size_set)); + cls->defineProperty("count", _SE(js_cc_gfx_FormatInfo_count_get), _SE(js_cc_gfx_FormatInfo_count_set)); + cls->defineProperty("type", _SE(js_cc_gfx_FormatInfo_type_get), _SE(js_cc_gfx_FormatInfo_type_set)); + cls->defineProperty("hasAlpha", _SE(js_cc_gfx_FormatInfo_hasAlpha_get), _SE(js_cc_gfx_FormatInfo_hasAlpha_set)); + cls->defineProperty("hasDepth", _SE(js_cc_gfx_FormatInfo_hasDepth_get), _SE(js_cc_gfx_FormatInfo_hasDepth_set)); + cls->defineProperty("hasStencil", _SE(js_cc_gfx_FormatInfo_hasStencil_get), _SE(js_cc_gfx_FormatInfo_hasStencil_set)); + cls->defineProperty("isCompressed", _SE(js_cc_gfx_FormatInfo_isCompressed_get), _SE(js_cc_gfx_FormatInfo_isCompressed_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_FormatInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_FormatInfo_proto = cls->getProto(); + __jsb_cc_gfx_FormatInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_MemoryStatus_class = nullptr; +se::Object* __jsb_cc_gfx_MemoryStatus_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_MemoryStatus) + +static bool js_cc_gfx_MemoryStatus_bufferSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bufferSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MemoryStatus_bufferSize_set) + +static bool js_cc_gfx_MemoryStatus_bufferSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bufferSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MemoryStatus_bufferSize_get) + +static bool js_cc_gfx_MemoryStatus_textureSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->textureSize, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_MemoryStatus_textureSize_set) + +static bool js_cc_gfx_MemoryStatus_textureSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->textureSize, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_MemoryStatus_textureSize_get) + +static bool js_cc_gfx_MemoryStatus_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::MemoryStatus *arg1 = (cc::gfx::MemoryStatus *) NULL ; + cc::gfx::MemoryStatus *arg2 = 0 ; + cc::gfx::MemoryStatus temp2 ; + cc::gfx::MemoryStatus *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(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::gfx::MemoryStatus *) &(arg1)->copy((cc::gfx::MemoryStatus 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_gfx_MemoryStatus_copy) + +static bool js_new_cc_gfx_MemoryStatus(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::MemoryStatus *result; + result = (cc::gfx::MemoryStatus *)new cc::gfx::MemoryStatus(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_MemoryStatus, __jsb_cc_gfx_MemoryStatus_class, js_delete_cc_gfx_MemoryStatus) + +static bool js_delete_cc_gfx_MemoryStatus(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_MemoryStatus) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MemoryStatus * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bufferSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bufferSize), ctx); + } + + + json->getProperty("textureSize", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->textureSize), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_MemoryStatus(se::Object* obj) { + auto* cls = se::Class::create("MemoryStatus", obj, nullptr, _SE(js_new_cc_gfx_MemoryStatus)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bufferSize", _SE(js_cc_gfx_MemoryStatus_bufferSize_get), _SE(js_cc_gfx_MemoryStatus_bufferSize_set)); + cls->defineProperty("textureSize", _SE(js_cc_gfx_MemoryStatus_textureSize_get), _SE(js_cc_gfx_MemoryStatus_textureSize_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_MemoryStatus_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_MemoryStatus)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_MemoryStatus_proto = cls->getProto(); + __jsb_cc_gfx_MemoryStatus_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DynamicStencilStates_class = nullptr; +se::Object* __jsb_cc_gfx_DynamicStencilStates_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStencilStates) + +static bool js_cc_gfx_DynamicStencilStates_writeMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->writeMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStencilStates_writeMask_set) + +static bool js_cc_gfx_DynamicStencilStates_writeMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->writeMask, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStencilStates_writeMask_get) + +static bool js_cc_gfx_DynamicStencilStates_compareMask_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->compareMask, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStencilStates_compareMask_set) + +static bool js_cc_gfx_DynamicStencilStates_compareMask_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->compareMask, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStencilStates_compareMask_get) + +static bool js_cc_gfx_DynamicStencilStates_reference_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reference, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStencilStates_reference_set) + +static bool js_cc_gfx_DynamicStencilStates_reference_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reference, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStencilStates_reference_get) + +static bool js_cc_gfx_DynamicStencilStates_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStencilStates *arg1 = (cc::gfx::DynamicStencilStates *) NULL ; + cc::gfx::DynamicStencilStates *arg2 = 0 ; + cc::gfx::DynamicStencilStates temp2 ; + cc::gfx::DynamicStencilStates *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(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::gfx::DynamicStencilStates *) &(arg1)->copy((cc::gfx::DynamicStencilStates 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_gfx_DynamicStencilStates_copy) + +static bool js_new_cc_gfx_DynamicStencilStates(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DynamicStencilStates *result; + result = (cc::gfx::DynamicStencilStates *)new cc::gfx::DynamicStencilStates(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DynamicStencilStates, __jsb_cc_gfx_DynamicStencilStates_class, js_delete_cc_gfx_DynamicStencilStates) + +static bool js_delete_cc_gfx_DynamicStencilStates(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStencilStates) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStencilStates * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("writeMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->writeMask), ctx); + } + + + json->getProperty("compareMask", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->compareMask), ctx); + } + + + json->getProperty("reference", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reference), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DynamicStencilStates(se::Object* obj) { + auto* cls = se::Class::create("DynamicStencilStates", obj, nullptr, _SE(js_new_cc_gfx_DynamicStencilStates)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("writeMask", _SE(js_cc_gfx_DynamicStencilStates_writeMask_get), _SE(js_cc_gfx_DynamicStencilStates_writeMask_set)); + cls->defineProperty("compareMask", _SE(js_cc_gfx_DynamicStencilStates_compareMask_get), _SE(js_cc_gfx_DynamicStencilStates_compareMask_set)); + cls->defineProperty("reference", _SE(js_cc_gfx_DynamicStencilStates_reference_get), _SE(js_cc_gfx_DynamicStencilStates_reference_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DynamicStencilStates_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DynamicStencilStates)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DynamicStencilStates_proto = cls->getProto(); + __jsb_cc_gfx_DynamicStencilStates_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DynamicStates_class = nullptr; +se::Object* __jsb_cc_gfx_DynamicStates_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStates) + +static bool js_cc_gfx_DynamicStates_viewport_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->viewport, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_viewport_set) + +static bool js_cc_gfx_DynamicStates_viewport_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->viewport, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->viewport, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_viewport_get) + +static bool js_cc_gfx_DynamicStates_scissor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->scissor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_scissor_set) + +static bool js_cc_gfx_DynamicStates_scissor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->scissor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->scissor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_scissor_get) + +static bool js_cc_gfx_DynamicStates_blendConstant_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blendConstant, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_blendConstant_set) + +static bool js_cc_gfx_DynamicStates_blendConstant_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blendConstant, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blendConstant, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_blendConstant_get) + +static bool js_cc_gfx_DynamicStates_lineWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lineWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_lineWidth_set) + +static bool js_cc_gfx_DynamicStates_lineWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lineWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_lineWidth_get) + +static bool js_cc_gfx_DynamicStates_depthBiasConstant_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasConstant, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthBiasConstant_set) + +static bool js_cc_gfx_DynamicStates_depthBiasConstant_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasConstant, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthBiasConstant_get) + +static bool js_cc_gfx_DynamicStates_depthBiasClamp_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasClamp, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthBiasClamp_set) + +static bool js_cc_gfx_DynamicStates_depthBiasClamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasClamp, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthBiasClamp_get) + +static bool js_cc_gfx_DynamicStates_depthBiasSlope_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthBiasSlope, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthBiasSlope_set) + +static bool js_cc_gfx_DynamicStates_depthBiasSlope_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthBiasSlope, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthBiasSlope_get) + +static bool js_cc_gfx_DynamicStates_depthMinBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthMinBounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthMinBounds_set) + +static bool js_cc_gfx_DynamicStates_depthMinBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthMinBounds, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthMinBounds_get) + +static bool js_cc_gfx_DynamicStates_depthMaxBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthMaxBounds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_depthMaxBounds_set) + +static bool js_cc_gfx_DynamicStates_depthMaxBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthMaxBounds, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_depthMaxBounds_get) + +static bool js_cc_gfx_DynamicStates_stencilStatesFront_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilStatesFront, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_stencilStatesFront_set) + +static bool js_cc_gfx_DynamicStates_stencilStatesFront_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilStatesFront, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilStatesFront, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_stencilStatesFront_get) + +static bool js_cc_gfx_DynamicStates_stencilStatesBack_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stencilStatesBack, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_DynamicStates_stencilStatesBack_set) + +static bool js_cc_gfx_DynamicStates_stencilStatesBack_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stencilStatesBack, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stencilStatesBack, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_DynamicStates_stencilStatesBack_get) + +static bool js_cc_gfx_DynamicStates_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DynamicStates *arg1 = (cc::gfx::DynamicStates *) NULL ; + cc::gfx::DynamicStates *arg2 = 0 ; + cc::gfx::DynamicStates temp2 ; + cc::gfx::DynamicStates *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(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::gfx::DynamicStates *) &(arg1)->copy((cc::gfx::DynamicStates 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_gfx_DynamicStates_copy) + +static bool js_new_cc_gfx_DynamicStates(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DynamicStates *result; + result = (cc::gfx::DynamicStates *)new cc::gfx::DynamicStates(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DynamicStates, __jsb_cc_gfx_DynamicStates_class, js_delete_cc_gfx_DynamicStates) + +static bool js_delete_cc_gfx_DynamicStates(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DynamicStates) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStates * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("viewport", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->viewport), ctx); + } + + + json->getProperty("scissor", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->scissor), ctx); + } + + + json->getProperty("blendConstant", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blendConstant), ctx); + } + + + json->getProperty("lineWidth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lineWidth), ctx); + } + + + json->getProperty("depthBiasConstant", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasConstant), ctx); + } + + + json->getProperty("depthBiasClamp", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasClamp), ctx); + } + + + json->getProperty("depthBiasSlope", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthBiasSlope), ctx); + } + + + json->getProperty("depthMinBounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthMinBounds), ctx); + } + + + json->getProperty("depthMaxBounds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthMaxBounds), ctx); + } + + + json->getProperty("stencilStatesFront", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilStatesFront), ctx); + } + + + json->getProperty("stencilStatesBack", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stencilStatesBack), ctx); + } + + + return ok; +} + + +bool js_register_cc_gfx_DynamicStates(se::Object* obj) { + auto* cls = se::Class::create("DynamicStates", obj, nullptr, _SE(js_new_cc_gfx_DynamicStates)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("viewport", _SE(js_cc_gfx_DynamicStates_viewport_get), _SE(js_cc_gfx_DynamicStates_viewport_set)); + cls->defineProperty("scissor", _SE(js_cc_gfx_DynamicStates_scissor_get), _SE(js_cc_gfx_DynamicStates_scissor_set)); + cls->defineProperty("blendConstant", _SE(js_cc_gfx_DynamicStates_blendConstant_get), _SE(js_cc_gfx_DynamicStates_blendConstant_set)); + cls->defineProperty("lineWidth", _SE(js_cc_gfx_DynamicStates_lineWidth_get), _SE(js_cc_gfx_DynamicStates_lineWidth_set)); + cls->defineProperty("depthBiasConstant", _SE(js_cc_gfx_DynamicStates_depthBiasConstant_get), _SE(js_cc_gfx_DynamicStates_depthBiasConstant_set)); + cls->defineProperty("depthBiasClamp", _SE(js_cc_gfx_DynamicStates_depthBiasClamp_get), _SE(js_cc_gfx_DynamicStates_depthBiasClamp_set)); + cls->defineProperty("depthBiasSlope", _SE(js_cc_gfx_DynamicStates_depthBiasSlope_get), _SE(js_cc_gfx_DynamicStates_depthBiasSlope_set)); + cls->defineProperty("depthMinBounds", _SE(js_cc_gfx_DynamicStates_depthMinBounds_get), _SE(js_cc_gfx_DynamicStates_depthMinBounds_set)); + cls->defineProperty("depthMaxBounds", _SE(js_cc_gfx_DynamicStates_depthMaxBounds_get), _SE(js_cc_gfx_DynamicStates_depthMaxBounds_set)); + cls->defineProperty("stencilStatesFront", _SE(js_cc_gfx_DynamicStates_stencilStatesFront_get), _SE(js_cc_gfx_DynamicStates_stencilStatesFront_set)); + cls->defineProperty("stencilStatesBack", _SE(js_cc_gfx_DynamicStates_stencilStatesBack_get), _SE(js_cc_gfx_DynamicStates_stencilStatesBack_set)); + + cls->defineFunction("copy", _SE(js_cc_gfx_DynamicStates_copy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DynamicStates)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DynamicStates_proto = cls->getProto(); + __jsb_cc_gfx_DynamicStates_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_GFXObject_class = nullptr; +se::Object* __jsb_cc_gfx_GFXObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_GFXObject) + +static bool js_new_cc_gfx_GFXObject(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::ObjectType arg1 ; + cc::gfx::GFXObject *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::GFXObject *)new cc::gfx::GFXObject(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_GFXObject, __jsb_cc_gfx_GFXObject_class, js_delete_cc_gfx_GFXObject) + +static bool js_delete_cc_gfx_GFXObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_GFXObject) + +static bool js_cc_gfx_GFXObject_getObjectID_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::gfx::GFXObject::getObjectID((cc::gfx::GFXObject const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_GFXObject_getObjectID_static) + +static bool js_cc_gfx_GFXObject_objectType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + cc::gfx::ObjectType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::ObjectType)cc_gfx_GFXObject_objectType_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_gfx_GFXObject_objectType_get) + +static bool js_cc_gfx_GFXObject_objectID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_GFXObject_objectID_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GFXObject_objectID_get) + +static bool js_cc_gfx_GFXObject_typedID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GFXObject *arg1 = (cc::gfx::GFXObject *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_GFXObject_typedID_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_GFXObject_typedID_get) + +bool js_register_cc_gfx_GFXObject(se::Object* obj) { + auto* cls = se::Class::create("GFXObject", obj, nullptr, _SE(js_new_cc_gfx_GFXObject)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("objectType", _SE(js_cc_gfx_GFXObject_objectType_get), nullptr); + cls->defineProperty("objectID", _SE(js_cc_gfx_GFXObject_objectID_get), nullptr); + cls->defineProperty("typedID", _SE(js_cc_gfx_GFXObject_typedID_get), nullptr); + + + + cls->defineStaticFunction("getObjectID", _SE(js_cc_gfx_GFXObject_getObjectID_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_GFXObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_GFXObject_proto = cls->getProto(); + __jsb_cc_gfx_GFXObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Buffer_class = nullptr; +se::Object* __jsb_cc_gfx_Buffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Buffer) + +static bool js_delete_cc_gfx_Buffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Buffer) + +static bool js_cc_gfx_Buffer_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferInfo *arg1 = 0 ; + cc::gfx::BufferInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Buffer::computeHash((cc::gfx::BufferInfo const &)*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_FUNC(js_cc_gfx_Buffer_computeHash_static) + +static bool js_cc_gfx_Buffer_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Buffer_resize) + +static bool js_cc_gfx_Buffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Buffer_destroy) + +static bool js_cc_gfx_Buffer_isBufferView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gfx::Buffer const *)arg1)->isBufferView(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Buffer_isBufferView) + +static bool js_cc_gfx_Buffer_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferUsage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferUsage)cc_gfx_Buffer_usage_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_gfx_Buffer_usage_get) + +static bool js_cc_gfx_Buffer_memUsage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + cc::gfx::MemoryUsage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::MemoryUsage)cc_gfx_Buffer_memUsage_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_gfx_Buffer_memUsage_get) + +static bool js_cc_gfx_Buffer_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Buffer_stride_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Buffer_stride_get) + +static bool js_cc_gfx_Buffer_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Buffer_count_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Buffer_count_get) + +static bool js_cc_gfx_Buffer_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Buffer_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Buffer_size_get) + +static bool js_cc_gfx_Buffer_flags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Buffer *arg1 = (cc::gfx::Buffer *) NULL ; + cc::gfx::BufferFlags result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferFlags)cc_gfx_Buffer_flags_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_gfx_Buffer_flags_get) + +bool js_register_cc_gfx_Buffer(se::Object* obj) { + auto* cls = se::Class::create("Buffer", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("usage", _SE(js_cc_gfx_Buffer_usage_get), nullptr); + cls->defineProperty("memUsage", _SE(js_cc_gfx_Buffer_memUsage_get), nullptr); + cls->defineProperty("stride", _SE(js_cc_gfx_Buffer_stride_get), nullptr); + cls->defineProperty("count", _SE(js_cc_gfx_Buffer_count_get), nullptr); + cls->defineProperty("size", _SE(js_cc_gfx_Buffer_size_get), nullptr); + cls->defineProperty("flags", _SE(js_cc_gfx_Buffer_flags_get), nullptr); + + cls->defineFunction("resize", _SE(js_cc_gfx_Buffer_resize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Buffer_destroy)); + cls->defineFunction("isBufferView", _SE(js_cc_gfx_Buffer_isBufferView)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Buffer_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Buffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Buffer_proto = cls->getProto(); + __jsb_cc_gfx_Buffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_CommandBuffer_class = nullptr; +se::Object* __jsb_cc_gfx_CommandBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_CommandBuffer) + +static bool js_delete_cc_gfx_CommandBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_CommandBuffer) + +static bool js_cc_gfx_CommandBuffer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::CommandBufferInfo *arg2 = 0 ; + cc::gfx::CommandBufferInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::CommandBufferInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_initialize) + +static bool js_cc_gfx_CommandBuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_destroy) + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + uint32_t arg3 ; + cc::gfx::Framebuffer *arg4 = (cc::gfx::Framebuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->begin(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_end(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->end(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_end) + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::Color *arg5 = (cc::gfx::Color *) NULL ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::CommandBuffer **arg8 = (cc::gfx::CommandBuffer **) NULL ; + uint32_t arg9 ; + cc::gfx::Rect temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::Color const *)arg5,arg6,arg7,(cc::gfx::CommandBuffer *const *)arg8,arg9); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_endRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endRenderPass(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_endRenderPass) + +static bool js_cc_gfx_CommandBuffer_insertMarker(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::MarkerInfo *arg2 = 0 ; + cc::gfx::MarkerInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->insertMarker((cc::gfx::MarkerInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_insertMarker) + +static bool js_cc_gfx_CommandBuffer_beginMarker(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::MarkerInfo *arg2 = 0 ; + cc::gfx::MarkerInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->beginMarker((cc::gfx::MarkerInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_beginMarker) + +static bool js_cc_gfx_CommandBuffer_endMarker(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endMarker(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_endMarker) + +static bool js_cc_gfx_CommandBuffer_bindPipelineState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::PipelineState *arg2 = (cc::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(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_gfx_CommandBuffer_bindPipelineState) + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg4 ; + uint32_t *arg5 = (uint32_t *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindDescriptorSet(arg2,arg3,arg4,(uint32_t const *)arg5); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_bindInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::InputAssembler *arg2 = (cc::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(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_gfx_CommandBuffer_bindInputAssembler) + +static bool js_cc_gfx_CommandBuffer_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Viewport *arg2 = 0 ; + cc::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(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((cc::gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setViewport) + +static bool js_cc_gfx_CommandBuffer_setScissor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Rect *arg2 = 0 ; + cc::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(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((cc::gfx::Rect const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setScissor) + +static bool js_cc_gfx_CommandBuffer_setLineWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLineWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setLineWidth) + +static bool js_cc_gfx_CommandBuffer_setDepthBias(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDepthBias(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setDepthBias) + +static bool js_cc_gfx_CommandBuffer_setBlendConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setBlendConstants((cc::gfx::Color const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setBlendConstants) + +static bool js_cc_gfx_CommandBuffer_setDepthBound(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDepthBound(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setDepthBound) + +static bool js_cc_gfx_CommandBuffer_setStencilWriteMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::StencilFace arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStencilWriteMask(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setStencilWriteMask) + +static bool js_cc_gfx_CommandBuffer_setStencilCompareMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::StencilFace arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStencilCompareMask(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_setStencilCompareMask) + +static bool js_cc_gfx_CommandBuffer_nextSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->nextSubpass(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_nextSubpass) + +static bool js_cc_gfx_CommandBuffer_drawWithInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::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(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((cc::gfx::DrawInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_drawWithInfo) + +static bool js_cc_gfx_CommandBuffer_blitTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureBlit *arg4 = (cc::gfx::TextureBlit *) NULL ; + uint32_t arg5 ; + cc::gfx::Filter arg6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->blitTexture(arg2,arg3,(cc::gfx::TextureBlit const *)arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_copyTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureCopy *arg4 = (cc::gfx::TextureCopy *) NULL ; + uint32_t arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->copyTexture(arg2,arg3,(cc::gfx::TextureCopy const *)arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_copyTexture) + +static bool js_cc_gfx_CommandBuffer_dispatch(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::DispatchInfo *arg2 = 0 ; + cc::gfx::DispatchInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->dispatch((cc::gfx::DispatchInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_dispatch) + +static bool js_cc_gfx_CommandBuffer_beginQuery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->beginQuery(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_beginQuery) + +static bool js_cc_gfx_CommandBuffer_endQuery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->endQuery(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_endQuery) + +static bool js_cc_gfx_CommandBuffer_resetQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resetQueryPool(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_resetQueryPool) + +static bool js_cc_gfx_CommandBuffer_completeQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->completeQueryPool(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_completeQueryPool) + +static bool js_cc_gfx_CommandBuffer_customCommand(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::CommandBuffer::CustomCommand *arg2 = 0 ; + cc::gfx::CommandBuffer::CustomCommand temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->customCommand((cc::gfx::CommandBuffer::CustomCommand &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_customCommand) + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::GeneralBarrier *arg2 = (cc::gfx::GeneralBarrier *) NULL ; + cc::gfx::BufferBarrier **arg3 = (cc::gfx::BufferBarrier **) NULL ; + cc::gfx::Buffer **arg4 = (cc::gfx::Buffer **) NULL ; + uint32_t arg5 ; + cc::gfx::TextureBarrier **arg6 = (cc::gfx::TextureBarrier **) NULL ; + cc::gfx::Texture **arg7 = (cc::gfx::Texture **) NULL ; + uint32_t arg8 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->pipelineBarrier((cc::gfx::GeneralBarrier const *)arg2,(cc::gfx::BufferBarrier const *const *)arg3,(cc::gfx::Buffer const *const *)arg4,arg5,(cc::gfx::TextureBarrier const *const *)arg6,(cc::gfx::Texture const *const *)arg7,arg8); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->begin(); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->begin(arg2); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->begin(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_begin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_CommandBuffer_begin__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_begin) + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindDescriptorSet(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + ccstd::vector< uint32_t > *arg4 = 0 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + (arg1)->bindDescriptorSet(arg2,arg3,(ccstd::vector< uint32_t > const &)*arg4); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_bindDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_gfx_CommandBuffer_bindDescriptorSet__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_bindDescriptorSet) + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::ColorList *arg5 = 0 ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::CommandBufferList *arg8 = 0 ; + cc::gfx::Rect temp4 ; + cc::gfx::ColorList temp5 ; + cc::gfx::CommandBufferList temp8 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::ColorList const &)*arg5,arg6,arg7,(cc::gfx::CommandBufferList const &)*arg8); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::ColorList *arg5 = 0 ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::Rect temp4 ; + cc::gfx::ColorList temp5 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::ColorList const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::RenderPass *arg2 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Rect *arg4 = 0 ; + cc::gfx::Color *arg5 = (cc::gfx::Color *) NULL ; + float arg6 ; + uint32_t arg7 ; + cc::gfx::Rect temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->beginRenderPass(arg2,arg3,(cc::gfx::Rect const &)*arg4,(cc::gfx::Color const *)arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_beginRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_gfx_CommandBuffer_beginRenderPass__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_beginRenderPass) + +static bool js_cc_gfx_CommandBuffer_draw(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::InputAssembler *arg2 = (cc::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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->draw(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_draw) + +static bool js_cc_gfx_CommandBuffer_blitTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureBlitList *arg4 = 0 ; + cc::gfx::Filter arg5 ; + cc::gfx::TextureBlitList temp4 ; + + arg1 = SE_THIS_OBJECT(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; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->blitTexture(arg2,arg3,(cc::gfx::TextureBlitList const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_blitTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_gfx_CommandBuffer_blitTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_gfx_CommandBuffer_blitTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_blitTexture) + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::GeneralBarrier *arg2 = (cc::gfx::GeneralBarrier *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->pipelineBarrier((cc::gfx::GeneralBarrier const *)arg2); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::GeneralBarrier *arg2 = (cc::gfx::GeneralBarrier *) NULL ; + cc::gfx::BufferBarrierList *arg3 = 0 ; + cc::gfx::BufferList *arg4 = 0 ; + cc::gfx::TextureBarrierList *arg5 = 0 ; + cc::gfx::TextureList *arg6 = 0 ; + cc::gfx::BufferBarrierList temp3 ; + cc::gfx::BufferList temp4 ; + cc::gfx::TextureBarrierList temp5 ; + cc::gfx::TextureList temp6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->pipelineBarrier((cc::gfx::GeneralBarrier const *)arg2,(cc::gfx::BufferBarrierList const &)*arg3,(cc::gfx::BufferList const &)*arg4,(cc::gfx::TextureBarrierList const &)*arg5,(cc::gfx::TextureList const &)*arg6); + + + return true; +} + +static bool js_cc_gfx_CommandBuffer_pipelineBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_gfx_CommandBuffer_pipelineBarrier__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_CommandBuffer_pipelineBarrier) + +static bool js_cc_gfx_CommandBuffer_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::CommandBufferType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::CommandBufferType)cc_gfx_CommandBuffer_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_type_get) + +static bool js_cc_gfx_CommandBuffer_queue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + cc::gfx::Queue *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Queue *)cc_gfx_CommandBuffer_queue_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_gfx_CommandBuffer_queue_get) + +static bool js_cc_gfx_CommandBuffer_numDrawCalls_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_CommandBuffer_numDrawCalls_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_numDrawCalls_get) + +static bool js_cc_gfx_CommandBuffer_numInstances_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_CommandBuffer_numInstances_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_numInstances_get) + +static bool js_cc_gfx_CommandBuffer_numTris_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::CommandBuffer *arg1 = (cc::gfx::CommandBuffer *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_CommandBuffer_numTris_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_CommandBuffer_numTris_get) + +bool js_register_cc_gfx_CommandBuffer(se::Object* obj) { + auto* cls = se::Class::create("CommandBuffer", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_CommandBuffer_type_get), nullptr); + cls->defineProperty("queue", _SE(js_cc_gfx_CommandBuffer_queue_get), nullptr); + cls->defineProperty("numDrawCalls", _SE(js_cc_gfx_CommandBuffer_numDrawCalls_get), nullptr); + cls->defineProperty("numInstances", _SE(js_cc_gfx_CommandBuffer_numInstances_get), nullptr); + cls->defineProperty("numTris", _SE(js_cc_gfx_CommandBuffer_numTris_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_CommandBuffer_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_CommandBuffer_destroy)); + cls->defineFunction("end", _SE(js_cc_gfx_CommandBuffer_end)); + cls->defineFunction("endRenderPass", _SE(js_cc_gfx_CommandBuffer_endRenderPass)); + cls->defineFunction("insertMarker", _SE(js_cc_gfx_CommandBuffer_insertMarker)); + cls->defineFunction("beginMarker", _SE(js_cc_gfx_CommandBuffer_beginMarker)); + cls->defineFunction("endMarker", _SE(js_cc_gfx_CommandBuffer_endMarker)); + cls->defineFunction("bindPipelineState", _SE(js_cc_gfx_CommandBuffer_bindPipelineState)); + cls->defineFunction("bindInputAssembler", _SE(js_cc_gfx_CommandBuffer_bindInputAssembler)); + cls->defineFunction("setViewport", _SE(js_cc_gfx_CommandBuffer_setViewport)); + cls->defineFunction("setScissor", _SE(js_cc_gfx_CommandBuffer_setScissor)); + cls->defineFunction("setLineWidth", _SE(js_cc_gfx_CommandBuffer_setLineWidth)); + cls->defineFunction("setDepthBias", _SE(js_cc_gfx_CommandBuffer_setDepthBias)); + cls->defineFunction("setBlendConstants", _SE(js_cc_gfx_CommandBuffer_setBlendConstants)); + cls->defineFunction("setDepthBound", _SE(js_cc_gfx_CommandBuffer_setDepthBound)); + cls->defineFunction("setStencilWriteMask", _SE(js_cc_gfx_CommandBuffer_setStencilWriteMask)); + cls->defineFunction("setStencilCompareMask", _SE(js_cc_gfx_CommandBuffer_setStencilCompareMask)); + cls->defineFunction("nextSubpass", _SE(js_cc_gfx_CommandBuffer_nextSubpass)); + cls->defineFunction("drawWithInfo", _SE(js_cc_gfx_CommandBuffer_drawWithInfo)); + cls->defineFunction("copyTexture", _SE(js_cc_gfx_CommandBuffer_copyTexture)); + cls->defineFunction("dispatch", _SE(js_cc_gfx_CommandBuffer_dispatch)); + cls->defineFunction("beginQuery", _SE(js_cc_gfx_CommandBuffer_beginQuery)); + cls->defineFunction("endQuery", _SE(js_cc_gfx_CommandBuffer_endQuery)); + cls->defineFunction("resetQueryPool", _SE(js_cc_gfx_CommandBuffer_resetQueryPool)); + cls->defineFunction("completeQueryPool", _SE(js_cc_gfx_CommandBuffer_completeQueryPool)); + cls->defineFunction("customCommand", _SE(js_cc_gfx_CommandBuffer_customCommand)); + cls->defineFunction("begin", _SE(js_cc_gfx_CommandBuffer_begin)); + cls->defineFunction("bindDescriptorSet", _SE(js_cc_gfx_CommandBuffer_bindDescriptorSet)); + cls->defineFunction("beginRenderPass", _SE(js_cc_gfx_CommandBuffer_beginRenderPass)); + cls->defineFunction("draw", _SE(js_cc_gfx_CommandBuffer_draw)); + cls->defineFunction("blitTexture", _SE(js_cc_gfx_CommandBuffer_blitTexture)); + cls->defineFunction("pipelineBarrier", _SE(js_cc_gfx_CommandBuffer_pipelineBarrier)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_CommandBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_CommandBuffer_proto = cls->getProto(); + __jsb_cc_gfx_CommandBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSet_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSet_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSet) + +static bool js_delete_cc_gfx_DescriptorSet(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSet) + +static bool js_cc_gfx_DescriptorSet_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + cc::gfx::DescriptorSetInfo *arg2 = 0 ; + cc::gfx::DescriptorSetInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::DescriptorSetInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_initialize) + +static bool js_cc_gfx_DescriptorSet_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_destroy) + +static bool js_cc_gfx_DescriptorSet_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_update) + +static bool js_cc_gfx_DescriptorSet_bindBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + uint32_t arg4 ; + cc::gfx::AccessFlags arg5 ; + + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindSampler__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + cc::gfx::AccessFlags arg5 ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindBufferJSB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + uint32_t arg4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->bindBufferJSB(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindBufferJSB) + +static bool js_cc_gfx_DescriptorSet_bindTextureJSB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + cc::gfx::AccessFlags arg5 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->bindTextureJSB(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindTextureJSB) + +static bool js_cc_gfx_DescriptorSet_bindSamplerJSB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + uint32_t arg4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->bindSamplerJSB(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindSamplerJSB) + +static bool js_cc_gfx_DescriptorSet_getBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Buffer *)((cc::gfx::DescriptorSet const *)arg1)->getBuffer(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_gfx_DescriptorSet_getTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Texture *)((cc::gfx::DescriptorSet const *)arg1)->getTexture(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_gfx_DescriptorSet_getSampler__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::Sampler *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Sampler *)((cc::gfx::DescriptorSet const *)arg1)->getSampler(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_gfx_DescriptorSet_bindBuffer__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_gfx_DescriptorSet_bindBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_gfx_DescriptorSet_bindBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_bindBuffer__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindBuffer) + +static bool js_cc_gfx_DescriptorSet_bindTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_gfx_DescriptorSet_bindTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_gfx_DescriptorSet_bindTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_bindTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindTexture) + +static bool js_cc_gfx_DescriptorSet_bindSampler__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_DescriptorSet_bindSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_gfx_DescriptorSet_bindSampler__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_bindSampler__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_bindSampler) + +static bool js_cc_gfx_DescriptorSet_getBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Buffer *)((cc::gfx::DescriptorSet const *)arg1)->getBuffer(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_gfx_DescriptorSet_getBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_getBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DescriptorSet_getBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_getBuffer) + +static bool js_cc_gfx_DescriptorSet_getTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Texture *)((cc::gfx::DescriptorSet const *)arg1)->getTexture(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_gfx_DescriptorSet_getTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_getTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DescriptorSet_getTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_getTexture) + +static bool js_cc_gfx_DescriptorSet_getSampler__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Sampler *)((cc::gfx::DescriptorSet const *)arg1)->getSampler(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_gfx_DescriptorSet_getSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_DescriptorSet_getSampler__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DescriptorSet_getSampler__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSet_getSampler) + +static bool js_cc_gfx_DescriptorSet_layout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSet *arg1 = (cc::gfx::DescriptorSet *) NULL ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)cc_gfx_DescriptorSet_layout_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_gfx_DescriptorSet_layout_get) + +bool js_register_cc_gfx_DescriptorSet(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSet", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("layout", _SE(js_cc_gfx_DescriptorSet_layout_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_DescriptorSet_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_DescriptorSet_destroy)); + cls->defineFunction("update", _SE(js_cc_gfx_DescriptorSet_update)); + cls->defineFunction("bindBufferJSB", _SE(js_cc_gfx_DescriptorSet_bindBufferJSB)); + cls->defineFunction("bindTextureJSB", _SE(js_cc_gfx_DescriptorSet_bindTextureJSB)); + cls->defineFunction("bindSamplerJSB", _SE(js_cc_gfx_DescriptorSet_bindSamplerJSB)); + cls->defineFunction("bindBuffer", _SE(js_cc_gfx_DescriptorSet_bindBuffer)); + cls->defineFunction("bindTexture", _SE(js_cc_gfx_DescriptorSet_bindTexture)); + cls->defineFunction("bindSampler", _SE(js_cc_gfx_DescriptorSet_bindSampler)); + cls->defineFunction("getBuffer", _SE(js_cc_gfx_DescriptorSet_getBuffer)); + cls->defineFunction("getTexture", _SE(js_cc_gfx_DescriptorSet_getTexture)); + cls->defineFunction("getSampler", _SE(js_cc_gfx_DescriptorSet_getSampler)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSet)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSet_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSet_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DescriptorSetLayout_class = nullptr; +se::Object* __jsb_cc_gfx_DescriptorSetLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayout) + +static bool js_delete_cc_gfx_DescriptorSetLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DescriptorSetLayout) + +static bool js_cc_gfx_DescriptorSetLayout_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + cc::gfx::DescriptorSetLayoutInfo *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::DescriptorSetLayoutInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSetLayout_initialize) + +static bool js_cc_gfx_DescriptorSetLayout_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSetLayout_destroy) + +static bool js_cc_gfx_DescriptorSetLayout_getDynamicBindings(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + ccstd::vector< uint32_t > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< uint32_t > *) &((cc::gfx::DescriptorSetLayout const *)arg1)->getDynamicBindings(); + + 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_gfx_DescriptorSetLayout_getDynamicBindings) + +static bool js_cc_gfx_DescriptorSetLayout_getDescriptorCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::DescriptorSetLayout const *)arg1)->getDescriptorCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_DescriptorSetLayout_getDescriptorCount) + +static bool js_cc_gfx_DescriptorSetLayout_bindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::DescriptorSetLayout *arg1 = (cc::gfx::DescriptorSetLayout *) NULL ; + cc::gfx::DescriptorSetLayoutBindingList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayoutBindingList *) &cc_gfx_DescriptorSetLayout_bindings_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_gfx_DescriptorSetLayout_bindings_get) + +bool js_register_cc_gfx_DescriptorSetLayout(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayout", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindings", _SE(js_cc_gfx_DescriptorSetLayout_bindings_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_DescriptorSetLayout_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_DescriptorSetLayout_destroy)); + cls->defineFunction("getDynamicBindings", _SE(js_cc_gfx_DescriptorSetLayout_getDynamicBindings)); + cls->defineFunction("getDescriptorCount", _SE(js_cc_gfx_DescriptorSetLayout_getDescriptorCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DescriptorSetLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DescriptorSetLayout_proto = cls->getProto(); + __jsb_cc_gfx_DescriptorSetLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Framebuffer_class = nullptr; +se::Object* __jsb_cc_gfx_Framebuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Framebuffer) + +static bool js_delete_cc_gfx_Framebuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Framebuffer) + +static bool js_cc_gfx_Framebuffer_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::FramebufferInfo *arg1 = 0 ; + cc::gfx::FramebufferInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Framebuffer::computeHash((cc::gfx::FramebufferInfo const &)*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_FUNC(js_cc_gfx_Framebuffer_computeHash_static) + +static bool js_cc_gfx_Framebuffer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::FramebufferInfo *arg2 = 0 ; + cc::gfx::FramebufferInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::FramebufferInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Framebuffer_initialize) + +static bool js_cc_gfx_Framebuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Framebuffer_destroy) + +static bool js_cc_gfx_Framebuffer_getDepthStencilResolveTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Texture *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)((cc::gfx::Framebuffer const *)arg1)->getDepthStencilResolveTexture(); + + 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_gfx_Framebuffer_getDepthStencilResolveTexture) + +static bool js_cc_gfx_Framebuffer_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::RenderPass *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RenderPass *)cc_gfx_Framebuffer_renderPass_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_gfx_Framebuffer_renderPass_get) + +static bool js_cc_gfx_Framebuffer_colorTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::TextureList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureList *) &cc_gfx_Framebuffer_colorTextures_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_gfx_Framebuffer_colorTextures_get) + +static bool js_cc_gfx_Framebuffer_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Framebuffer *arg1 = (cc::gfx::Framebuffer *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_gfx_Framebuffer_depthStencilTexture_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_gfx_Framebuffer_depthStencilTexture_get) + +bool js_register_cc_gfx_Framebuffer(se::Object* obj) { + auto* cls = se::Class::create("Framebuffer", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderPass", _SE(js_cc_gfx_Framebuffer_renderPass_get), nullptr); + cls->defineProperty("colorTextures", _SE(js_cc_gfx_Framebuffer_colorTextures_get), nullptr); + cls->defineProperty("depthStencilTexture", _SE(js_cc_gfx_Framebuffer_depthStencilTexture_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Framebuffer_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Framebuffer_destroy)); + cls->defineFunction("getDepthStencilResolveTexture", _SE(js_cc_gfx_Framebuffer_getDepthStencilResolveTexture)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Framebuffer_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Framebuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Framebuffer_proto = cls->getProto(); + __jsb_cc_gfx_Framebuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_InputAssembler_class = nullptr; +se::Object* __jsb_cc_gfx_InputAssembler_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_InputAssembler) + +static bool js_delete_cc_gfx_InputAssembler(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_InputAssembler) + +static bool js_cc_gfx_InputAssembler_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::InputAssemblerInfo *arg2 = 0 ; + cc::gfx::InputAssemblerInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::InputAssemblerInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_InputAssembler_initialize) + +static bool js_cc_gfx_InputAssembler_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_InputAssembler_destroy) + +static bool js_cc_gfx_InputAssembler_vertexBuffers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::BufferList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &cc_gfx_InputAssembler_vertexBuffers_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_gfx_InputAssembler_vertexBuffers_get) + +static bool js_cc_gfx_InputAssembler_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::AttributeList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::AttributeList *) &cc_gfx_InputAssembler_attributes_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_gfx_InputAssembler_attributes_get) + +static bool js_cc_gfx_InputAssembler_indexBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_gfx_InputAssembler_indexBuffer_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_gfx_InputAssembler_indexBuffer_get) + +static bool js_cc_gfx_InputAssembler_indirectBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_gfx_InputAssembler_indirectBuffer_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_gfx_InputAssembler_indirectBuffer_get) + +static bool js_cc_gfx_InputAssembler_attributesHash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_attributesHash_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_attributesHash_get) + +static bool js_cc_gfx_InputAssembler_drawInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::DrawInfo *arg2 = 0 ; + cc::gfx::DrawInfo temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_gfx_InputAssembler_drawInfo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_drawInfo_set) + +static bool js_cc_gfx_InputAssembler_drawInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + cc::gfx::DrawInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DrawInfo *) &cc_gfx_InputAssembler_drawInfo_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_gfx_InputAssembler_drawInfo_get) + +static bool js_cc_gfx_InputAssembler_vertexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_vertexCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_vertexCount_set) + +static bool js_cc_gfx_InputAssembler_vertexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_vertexCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_vertexCount_get) + +static bool js_cc_gfx_InputAssembler_firstVertex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_firstVertex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_firstVertex_set) + +static bool js_cc_gfx_InputAssembler_firstVertex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_firstVertex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_firstVertex_get) + +static bool js_cc_gfx_InputAssembler_indexCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_indexCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_indexCount_set) + +static bool js_cc_gfx_InputAssembler_indexCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_indexCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_indexCount_get) + +static bool js_cc_gfx_InputAssembler_firstIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_firstIndex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_firstIndex_set) + +static bool js_cc_gfx_InputAssembler_firstIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_firstIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_firstIndex_get) + +static bool js_cc_gfx_InputAssembler_vertexOffset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_vertexOffset_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_vertexOffset_set) + +static bool js_cc_gfx_InputAssembler_vertexOffset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_vertexOffset_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_vertexOffset_get) + +static bool js_cc_gfx_InputAssembler_instanceCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_instanceCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_instanceCount_set) + +static bool js_cc_gfx_InputAssembler_instanceCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_instanceCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_instanceCount_get) + +static bool js_cc_gfx_InputAssembler_firstInstance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gfx_InputAssembler_firstInstance_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gfx_InputAssembler_firstInstance_set) + +static bool js_cc_gfx_InputAssembler_firstInstance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::InputAssembler *arg1 = (cc::gfx::InputAssembler *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_InputAssembler_firstInstance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_InputAssembler_firstInstance_get) + +bool js_register_cc_gfx_InputAssembler(se::Object* obj) { + auto* cls = se::Class::create("InputAssembler", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("vertexBuffers", _SE(js_cc_gfx_InputAssembler_vertexBuffers_get), nullptr); + cls->defineProperty("attributes", _SE(js_cc_gfx_InputAssembler_attributes_get), nullptr); + cls->defineProperty("indexBuffer", _SE(js_cc_gfx_InputAssembler_indexBuffer_get), nullptr); + cls->defineProperty("indirectBuffer", _SE(js_cc_gfx_InputAssembler_indirectBuffer_get), nullptr); + cls->defineProperty("attributesHash", _SE(js_cc_gfx_InputAssembler_attributesHash_get), nullptr); + cls->defineProperty("drawInfo", _SE(js_cc_gfx_InputAssembler_drawInfo_get), _SE(js_cc_gfx_InputAssembler_drawInfo_set)); + cls->defineProperty("vertexCount", _SE(js_cc_gfx_InputAssembler_vertexCount_get), _SE(js_cc_gfx_InputAssembler_vertexCount_set)); + cls->defineProperty("firstVertex", _SE(js_cc_gfx_InputAssembler_firstVertex_get), _SE(js_cc_gfx_InputAssembler_firstVertex_set)); + cls->defineProperty("indexCount", _SE(js_cc_gfx_InputAssembler_indexCount_get), _SE(js_cc_gfx_InputAssembler_indexCount_set)); + cls->defineProperty("firstIndex", _SE(js_cc_gfx_InputAssembler_firstIndex_get), _SE(js_cc_gfx_InputAssembler_firstIndex_set)); + cls->defineProperty("vertexOffset", _SE(js_cc_gfx_InputAssembler_vertexOffset_get), _SE(js_cc_gfx_InputAssembler_vertexOffset_set)); + cls->defineProperty("instanceCount", _SE(js_cc_gfx_InputAssembler_instanceCount_get), _SE(js_cc_gfx_InputAssembler_instanceCount_set)); + cls->defineProperty("firstInstance", _SE(js_cc_gfx_InputAssembler_firstInstance_get), _SE(js_cc_gfx_InputAssembler_firstInstance_set)); + + cls->defineFunction("initialize", _SE(js_cc_gfx_InputAssembler_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_InputAssembler_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_InputAssembler)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_InputAssembler_proto = cls->getProto(); + __jsb_cc_gfx_InputAssembler_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineLayout_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineLayout_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayout) + +static bool js_delete_cc_gfx_PipelineLayout(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineLayout) + +static bool js_cc_gfx_PipelineLayout_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayout *arg1 = (cc::gfx::PipelineLayout *) NULL ; + cc::gfx::PipelineLayoutInfo *arg2 = 0 ; + cc::gfx::PipelineLayoutInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::PipelineLayoutInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineLayout_initialize) + +static bool js_cc_gfx_PipelineLayout_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayout *arg1 = (cc::gfx::PipelineLayout *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineLayout_destroy) + +static bool js_cc_gfx_PipelineLayout_getSetLayouts(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineLayout *arg1 = (cc::gfx::PipelineLayout *) NULL ; + cc::gfx::DescriptorSetLayoutList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayoutList *) &((cc::gfx::PipelineLayout const *)arg1)->getSetLayouts(); + + 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_gfx_PipelineLayout_getSetLayouts) + +bool js_register_cc_gfx_PipelineLayout(se::Object* obj) { + auto* cls = se::Class::create("PipelineLayout", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_gfx_PipelineLayout_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_PipelineLayout_destroy)); + cls->defineFunction("getSetLayouts", _SE(js_cc_gfx_PipelineLayout_getSetLayouts)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineLayout)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineLayout_proto = cls->getProto(); + __jsb_cc_gfx_PipelineLayout_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_PipelineState_class = nullptr; +se::Object* __jsb_cc_gfx_PipelineState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_PipelineState) + +static bool js_delete_cc_gfx_PipelineState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_PipelineState) + +static bool js_cc_gfx_PipelineState_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PipelineStateInfo *arg2 = 0 ; + cc::gfx::PipelineStateInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::PipelineStateInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineState_initialize) + +static bool js_cc_gfx_PipelineState_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineState_destroy) + +static bool js_cc_gfx_PipelineState_getDynamicStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::DynamicStateFlags result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DynamicStateFlags)((cc::gfx::PipelineState const *)arg1)->getDynamicStates(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_PipelineState_getDynamicStates) + +static bool js_cc_gfx_PipelineState_getPipelineLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PipelineLayout *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PipelineLayout *)((cc::gfx::PipelineState const *)arg1)->getPipelineLayout(); + + 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_gfx_PipelineState_getPipelineLayout) + +static bool js_cc_gfx_PipelineState_shader_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)cc_gfx_PipelineState_shader_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_gfx_PipelineState_shader_get) + +static bool js_cc_gfx_PipelineState_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PrimitiveMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PrimitiveMode)cc_gfx_PipelineState_primitive_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_gfx_PipelineState_primitive_get) + +static bool js_cc_gfx_PipelineState_bindPoint_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::PipelineBindPoint result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PipelineBindPoint)cc_gfx_PipelineState_bindPoint_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_gfx_PipelineState_bindPoint_get) + +static bool js_cc_gfx_PipelineState_inputState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::InputState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputState *) &cc_gfx_PipelineState_inputState_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_gfx_PipelineState_inputState_get) + +static bool js_cc_gfx_PipelineState_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::RasterizerState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RasterizerState *) &cc_gfx_PipelineState_rasterizerState_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_gfx_PipelineState_rasterizerState_get) + +static bool js_cc_gfx_PipelineState_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::DepthStencilState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilState *) &cc_gfx_PipelineState_depthStencilState_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_gfx_PipelineState_depthStencilState_get) + +static bool js_cc_gfx_PipelineState_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::BlendState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BlendState *) &cc_gfx_PipelineState_blendState_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_gfx_PipelineState_blendState_get) + +static bool js_cc_gfx_PipelineState_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::PipelineState *arg1 = (cc::gfx::PipelineState *) NULL ; + cc::gfx::RenderPass *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RenderPass *)cc_gfx_PipelineState_renderPass_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_gfx_PipelineState_renderPass_get) + +bool js_register_cc_gfx_PipelineState(se::Object* obj) { + auto* cls = se::Class::create("PipelineState", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("shader", _SE(js_cc_gfx_PipelineState_shader_get), nullptr); + cls->defineProperty("primitive", _SE(js_cc_gfx_PipelineState_primitive_get), nullptr); + cls->defineProperty("bindPoint", _SE(js_cc_gfx_PipelineState_bindPoint_get), nullptr); + cls->defineProperty("inputState", _SE(js_cc_gfx_PipelineState_inputState_get), nullptr); + cls->defineProperty("rasterizerState", _SE(js_cc_gfx_PipelineState_rasterizerState_get), nullptr); + cls->defineProperty("depthStencilState", _SE(js_cc_gfx_PipelineState_depthStencilState_get), nullptr); + cls->defineProperty("blendState", _SE(js_cc_gfx_PipelineState_blendState_get), nullptr); + cls->defineProperty("renderPass", _SE(js_cc_gfx_PipelineState_renderPass_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_PipelineState_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_PipelineState_destroy)); + cls->defineFunction("getDynamicStates", _SE(js_cc_gfx_PipelineState_getDynamicStates)); + cls->defineFunction("getPipelineLayout", _SE(js_cc_gfx_PipelineState_getPipelineLayout)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_PipelineState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_PipelineState_proto = cls->getProto(); + __jsb_cc_gfx_PipelineState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_QueryPool_class = nullptr; +se::Object* __jsb_cc_gfx_QueryPool_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_QueryPool) + +static bool js_delete_cc_gfx_QueryPool(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_QueryPool) + +static bool js_cc_gfx_QueryPool_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + cc::gfx::QueryPoolInfo *arg2 = 0 ; + cc::gfx::QueryPoolInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::QueryPoolInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_initialize) + +static bool js_cc_gfx_QueryPool_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_destroy) + +static bool js_cc_gfx_QueryPool_hasResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->hasResult(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_hasResult) + +static bool js_cc_gfx_QueryPool_getResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + uint32_t arg2 ; + uint64_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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->getResult(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getResult) + +static bool js_cc_gfx_QueryPool_getType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + cc::gfx::QueryType result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueryType)((cc::gfx::QueryPool const *)arg1)->getType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getType) + +static bool js_cc_gfx_QueryPool_getMaxQueryObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::QueryPool const *)arg1)->getMaxQueryObjects(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getMaxQueryObjects) + +static bool js_cc_gfx_QueryPool_getForceWait(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::QueryPool *arg1 = (cc::gfx::QueryPool *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gfx::QueryPool const *)arg1)->getForceWait(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_QueryPool_getForceWait) + +bool js_register_cc_gfx_QueryPool(se::Object* obj) { + auto* cls = se::Class::create("QueryPool", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_gfx_QueryPool_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_QueryPool_destroy)); + cls->defineFunction("hasResult", _SE(js_cc_gfx_QueryPool_hasResult)); + cls->defineFunction("getResult", _SE(js_cc_gfx_QueryPool_getResult)); + cls->defineFunction("getType", _SE(js_cc_gfx_QueryPool_getType)); + cls->defineFunction("getMaxQueryObjects", _SE(js_cc_gfx_QueryPool_getMaxQueryObjects)); + cls->defineFunction("getForceWait", _SE(js_cc_gfx_QueryPool_getForceWait)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_QueryPool)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_QueryPool_proto = cls->getProto(); + __jsb_cc_gfx_QueryPool_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Queue_class = nullptr; +se::Object* __jsb_cc_gfx_Queue_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Queue) + +static bool js_delete_cc_gfx_Queue(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Queue) + +static bool js_cc_gfx_Queue_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::QueueInfo *arg2 = 0 ; + cc::gfx::QueueInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::QueueInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Queue_initialize) + +static bool js_cc_gfx_Queue_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Queue_destroy) + +static bool js_cc_gfx_Queue_submit__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::CommandBuffer **arg2 = (cc::gfx::CommandBuffer **) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->submit((cc::gfx::CommandBuffer *const *)arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_Queue_submit__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::CommandBufferList *arg2 = 0 ; + cc::gfx::CommandBufferList temp2 ; + + arg1 = SE_THIS_OBJECT(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)->submit((cc::gfx::CommandBufferList const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Queue_submit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_Queue_submit__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Queue_submit__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Queue_submit) + +static bool js_cc_gfx_Queue_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Queue *arg1 = (cc::gfx::Queue *) NULL ; + cc::gfx::QueueType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueueType)cc_gfx_Queue_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Queue_type_get) + +bool js_register_cc_gfx_Queue(se::Object* obj) { + auto* cls = se::Class::create("Queue", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_gfx_Queue_type_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Queue_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Queue_destroy)); + cls->defineFunction("submit", _SE(js_cc_gfx_Queue_submit)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Queue)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Queue_proto = cls->getProto(); + __jsb_cc_gfx_Queue_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_RenderPass_class = nullptr; +se::Object* __jsb_cc_gfx_RenderPass_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_RenderPass) + +static bool js_delete_cc_gfx_RenderPass(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_RenderPass) + +static bool js_cc_gfx_RenderPass_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPassInfo *arg1 = 0 ; + cc::gfx::RenderPassInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::RenderPass::computeHash((cc::gfx::RenderPassInfo const &)*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_FUNC(js_cc_gfx_RenderPass_computeHash_static) + +static bool js_cc_gfx_RenderPass_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::RenderPassInfo *arg2 = 0 ; + cc::gfx::RenderPassInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::RenderPassInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_RenderPass_initialize) + +static bool js_cc_gfx_RenderPass_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_RenderPass_destroy) + +static bool js_cc_gfx_RenderPass_getColorAttachments(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::ColorAttachmentList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::ColorAttachmentList *) &((cc::gfx::RenderPass const *)arg1)->getColorAttachments(); + + 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_gfx_RenderPass_getColorAttachments) + +static bool js_cc_gfx_RenderPass_getDepthStencilAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::DepthStencilAttachment *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilAttachment *) &((cc::gfx::RenderPass const *)arg1)->getDepthStencilAttachment(); + + 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_gfx_RenderPass_getDepthStencilAttachment) + +static bool js_cc_gfx_RenderPass_getDepthStencilResolveAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::DepthStencilAttachment *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilAttachment *) &((cc::gfx::RenderPass const *)arg1)->getDepthStencilResolveAttachment(); + + 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_gfx_RenderPass_getDepthStencilResolveAttachment) + +static bool js_cc_gfx_RenderPass_getSubpasses(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::SubpassInfoList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SubpassInfoList *) &((cc::gfx::RenderPass const *)arg1)->getSubpasses(); + + 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_gfx_RenderPass_getSubpasses) + +static bool js_cc_gfx_RenderPass_getDependencies(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + cc::gfx::SubpassDependencyList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SubpassDependencyList *) &((cc::gfx::RenderPass const *)arg1)->getDependencies(); + + 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_gfx_RenderPass_getDependencies) + +static bool js_cc_gfx_RenderPass_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::RenderPass *arg1 = (cc::gfx::RenderPass *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_RenderPass_hash_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_gfx_RenderPass_hash_get) + +bool js_register_cc_gfx_RenderPass(se::Object* obj) { + auto* cls = se::Class::create("RenderPass", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hash", _SE(js_cc_gfx_RenderPass_hash_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_RenderPass_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_RenderPass_destroy)); + cls->defineFunction("getColorAttachments", _SE(js_cc_gfx_RenderPass_getColorAttachments)); + cls->defineFunction("getDepthStencilAttachment", _SE(js_cc_gfx_RenderPass_getDepthStencilAttachment)); + cls->defineFunction("getDepthStencilResolveAttachment", _SE(js_cc_gfx_RenderPass_getDepthStencilResolveAttachment)); + cls->defineFunction("getSubpasses", _SE(js_cc_gfx_RenderPass_getSubpasses)); + cls->defineFunction("getDependencies", _SE(js_cc_gfx_RenderPass_getDependencies)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_RenderPass_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_RenderPass)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_RenderPass_proto = cls->getProto(); + __jsb_cc_gfx_RenderPass_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Shader_class = nullptr; +se::Object* __jsb_cc_gfx_Shader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Shader) + +static bool js_delete_cc_gfx_Shader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Shader) + +static bool js_cc_gfx_Shader_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::ShaderInfo *arg2 = 0 ; + cc::gfx::ShaderInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::ShaderInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Shader_initialize) + +static bool js_cc_gfx_Shader_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Shader_destroy) + +static bool js_cc_gfx_Shader_getBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformStorageBufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformStorageBufferList *) &((cc::gfx::Shader const *)arg1)->getBuffers(); + + 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_gfx_Shader_getBuffers) + +static bool js_cc_gfx_Shader_getSamplerTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformSamplerTextureList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformSamplerTextureList *) &((cc::gfx::Shader const *)arg1)->getSamplerTextures(); + + 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_gfx_Shader_getSamplerTextures) + +static bool js_cc_gfx_Shader_getTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformTextureList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformTextureList *) &((cc::gfx::Shader const *)arg1)->getTextures(); + + 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_gfx_Shader_getTextures) + +static bool js_cc_gfx_Shader_getImages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformStorageImageList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformStorageImageList *) &((cc::gfx::Shader const *)arg1)->getImages(); + + 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_gfx_Shader_getImages) + +static bool js_cc_gfx_Shader_getSubpassInputs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformInputAttachmentList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformInputAttachmentList *) &((cc::gfx::Shader const *)arg1)->getSubpassInputs(); + + 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_gfx_Shader_getSubpassInputs) + +static bool js_cc_gfx_Shader_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Shader_name_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_gfx_Shader_name_get) + +static bool js_cc_gfx_Shader_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::ShaderStageList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::ShaderStageList *) &cc_gfx_Shader_stages_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_gfx_Shader_stages_get) + +static bool js_cc_gfx_Shader_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::AttributeList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::AttributeList *) &cc_gfx_Shader_attributes_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_gfx_Shader_attributes_get) + +static bool js_cc_gfx_Shader_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformBlockList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformBlockList *) &cc_gfx_Shader_blocks_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_gfx_Shader_blocks_get) + +static bool js_cc_gfx_Shader_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Shader *arg1 = (cc::gfx::Shader *) NULL ; + cc::gfx::UniformSamplerList *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::UniformSamplerList *) &cc_gfx_Shader_samplers_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_gfx_Shader_samplers_get) + +bool js_register_cc_gfx_Shader(se::Object* obj) { + auto* cls = se::Class::create("Shader", obj, __jsb_cc_gfx_GFXObject_proto, 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_gfx_Shader_name_get), nullptr); + cls->defineProperty("stages", _SE(js_cc_gfx_Shader_stages_get), nullptr); + cls->defineProperty("attributes", _SE(js_cc_gfx_Shader_attributes_get), nullptr); + cls->defineProperty("blocks", _SE(js_cc_gfx_Shader_blocks_get), nullptr); + cls->defineProperty("samplers", _SE(js_cc_gfx_Shader_samplers_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Shader_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Shader_destroy)); + cls->defineFunction("getBuffers", _SE(js_cc_gfx_Shader_getBuffers)); + cls->defineFunction("getSamplerTextures", _SE(js_cc_gfx_Shader_getSamplerTextures)); + cls->defineFunction("getTextures", _SE(js_cc_gfx_Shader_getTextures)); + cls->defineFunction("getImages", _SE(js_cc_gfx_Shader_getImages)); + cls->defineFunction("getSubpassInputs", _SE(js_cc_gfx_Shader_getSubpassInputs)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Shader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Shader_proto = cls->getProto(); + __jsb_cc_gfx_Shader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Swapchain_class = nullptr; +se::Object* __jsb_cc_gfx_Swapchain_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Swapchain) + +static bool js_delete_cc_gfx_Swapchain(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Swapchain) + +static bool js_cc_gfx_Swapchain_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::SwapchainInfo *arg2 = 0 ; + cc::gfx::SwapchainInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::SwapchainInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_initialize) + +static bool js_cc_gfx_Swapchain_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_destroy) + +static bool js_cc_gfx_Swapchain_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::gfx::SurfaceTransform arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_resize) + +static bool js_cc_gfx_Swapchain_destroySurface(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroySurface(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_destroySurface) + +static bool js_cc_gfx_Swapchain_createSurface(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->createSurface(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_createSurface) + +static bool js_cc_gfx_Swapchain_getWindowId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::Swapchain const *)arg1)->getWindowId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_getWindowId) + +static bool js_cc_gfx_Swapchain_getWindowHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + void *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(s); + if (nullptr == arg1) return true; + result = (void *)((cc::gfx::Swapchain const *)arg1)->getWindowHandle(); + + 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_gfx_Swapchain_getWindowHandle) + +static bool js_cc_gfx_Swapchain_getVSyncMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::VsyncMode result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::VsyncMode)((cc::gfx::Swapchain const *)arg1)->getVSyncMode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_getVSyncMode) + +static bool js_cc_gfx_Swapchain_getGeneration(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::Swapchain const *)arg1)->getGeneration(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Swapchain_getGeneration) + +static bool js_cc_gfx_Swapchain_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Swapchain_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Swapchain_width_get) + +static bool js_cc_gfx_Swapchain_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Swapchain_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Swapchain_height_get) + +static bool js_cc_gfx_Swapchain_surfaceTransform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::SurfaceTransform result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SurfaceTransform)cc_gfx_Swapchain_surfaceTransform_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_gfx_Swapchain_surfaceTransform_get) + +static bool js_cc_gfx_Swapchain_colorTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_gfx_Swapchain_colorTexture_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_gfx_Swapchain_colorTexture_get) + +static bool js_cc_gfx_Swapchain_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Swapchain *arg1 = (cc::gfx::Swapchain *) NULL ; + cc::gfx::Texture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)cc_gfx_Swapchain_depthStencilTexture_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_gfx_Swapchain_depthStencilTexture_get) + +bool js_register_cc_gfx_Swapchain(se::Object* obj) { + auto* cls = se::Class::create("Swapchain", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_gfx_Swapchain_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_gfx_Swapchain_height_get), nullptr); + cls->defineProperty("surfaceTransform", _SE(js_cc_gfx_Swapchain_surfaceTransform_get), nullptr); + cls->defineProperty("colorTexture", _SE(js_cc_gfx_Swapchain_colorTexture_get), nullptr); + cls->defineProperty("depthStencilTexture", _SE(js_cc_gfx_Swapchain_depthStencilTexture_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Swapchain_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Swapchain_destroy)); + cls->defineFunction("resize", _SE(js_cc_gfx_Swapchain_resize)); + cls->defineFunction("destroySurface", _SE(js_cc_gfx_Swapchain_destroySurface)); + cls->defineFunction("createSurface", _SE(js_cc_gfx_Swapchain_createSurface)); + cls->defineFunction("getWindowId", _SE(js_cc_gfx_Swapchain_getWindowId)); + cls->defineFunction("getWindowHandle", _SE(js_cc_gfx_Swapchain_getWindowHandle)); + cls->defineFunction("getVSyncMode", _SE(js_cc_gfx_Swapchain_getVSyncMode)); + cls->defineFunction("getGeneration", _SE(js_cc_gfx_Swapchain_getGeneration)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Swapchain)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Swapchain_proto = cls->getProto(); + __jsb_cc_gfx_Swapchain_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Texture_class = nullptr; +se::Object* __jsb_cc_gfx_Texture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Texture) + +static bool js_delete_cc_gfx_Texture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Texture) + +static bool js_cc_gfx_Texture_computeHash_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::TextureInfo *arg1 = 0 ; + cc::gfx::TextureInfo temp1 ; + ccstd::hash_t result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Texture::computeHash((cc::gfx::TextureInfo const &)*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; +} + +static bool js_cc_gfx_Texture_computeHash_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::TextureViewInfo *arg1 = 0 ; + cc::gfx::TextureViewInfo temp1 ; + ccstd::hash_t result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Texture::computeHash((cc::gfx::TextureViewInfo const &)*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; +} + +static bool js_cc_gfx_Texture_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_gfx_Texture_computeHash_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Texture_computeHash_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Texture_computeHash_static) + +static bool js_cc_gfx_Texture_initialize__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureInfo *arg2 = 0 ; + cc::gfx::TextureInfo temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::TextureInfo const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Texture_initialize__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureViewInfo *arg2 = 0 ; + cc::gfx::TextureViewInfo temp2 ; + + arg1 = SE_THIS_OBJECT(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)->initialize((cc::gfx::TextureViewInfo const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Texture_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_gfx_Texture_initialize__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Texture_initialize__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Texture_initialize) + +static bool js_cc_gfx_Texture_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_resize) + +static bool js_cc_gfx_Texture_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_destroy) + +static bool js_cc_gfx_Texture_isTextureView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gfx::Texture const *)arg1)->isTextureView(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_isTextureView) + +static bool js_cc_gfx_Texture_getRaw(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::Texture *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Texture *)((cc::gfx::Texture const *)arg1)->getRaw(); + + 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_gfx_Texture_getRaw) + +static bool js_cc_gfx_Texture_getGLTextureHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::gfx::Texture const *)arg1)->getGLTextureHandle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Texture_getGLTextureHandle) + +static bool js_cc_gfx_Texture_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureInfo *) &cc_gfx_Texture_info_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_gfx_Texture_info_get) + +static bool js_cc_gfx_Texture_viewInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::TextureViewInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureViewInfo *) &cc_gfx_Texture_viewInfo_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_gfx_Texture_viewInfo_get) + +static bool js_cc_gfx_Texture_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Texture_width_get) + +static bool js_cc_gfx_Texture_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Texture_height_get) + +static bool js_cc_gfx_Texture_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + cc::gfx::Format result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Format)cc_gfx_Texture_format_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_gfx_Texture_format_get) + +static bool js_cc_gfx_Texture_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Texture_size_get) + +static bool js_cc_gfx_Texture_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Texture *arg1 = (cc::gfx::Texture *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Texture_hash_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_gfx_Texture_hash_get) + +bool js_register_cc_gfx_Texture(se::Object* obj) { + auto* cls = se::Class::create("Texture", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("info", _SE(js_cc_gfx_Texture_info_get), nullptr); + cls->defineProperty("viewInfo", _SE(js_cc_gfx_Texture_viewInfo_get), nullptr); + cls->defineProperty("width", _SE(js_cc_gfx_Texture_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_gfx_Texture_height_get), nullptr); + cls->defineProperty("format", _SE(js_cc_gfx_Texture_format_get), nullptr); + cls->defineProperty("size", _SE(js_cc_gfx_Texture_size_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_gfx_Texture_hash_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Texture_initialize)); + cls->defineFunction("resize", _SE(js_cc_gfx_Texture_resize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Texture_destroy)); + cls->defineFunction("isTextureView", _SE(js_cc_gfx_Texture_isTextureView)); + cls->defineFunction("getRaw", _SE(js_cc_gfx_Texture_getRaw)); + cls->defineFunction("getGLTextureHandle", _SE(js_cc_gfx_Texture_getGLTextureHandle)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Texture_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Texture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Texture_proto = cls->getProto(); + __jsb_cc_gfx_Texture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_GeneralBarrier_class = nullptr; +se::Object* __jsb_cc_gfx_GeneralBarrier_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrier) + +static bool js_new_cc_gfx_GeneralBarrier(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::GeneralBarrierInfo *arg1 = 0 ; + cc::gfx::GeneralBarrierInfo temp1 ; + cc::gfx::GeneralBarrier *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::GeneralBarrier *)new cc::gfx::GeneralBarrier((cc::gfx::GeneralBarrierInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_GeneralBarrier, __jsb_cc_gfx_GeneralBarrier_class, js_delete_cc_gfx_GeneralBarrier) + +static bool js_cc_gfx_GeneralBarrier_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::GeneralBarrierInfo *arg1 = 0 ; + cc::gfx::GeneralBarrierInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::GeneralBarrier::computeHash((cc::gfx::GeneralBarrierInfo const &)*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_FUNC(js_cc_gfx_GeneralBarrier_computeHash_static) + +static bool js_cc_gfx_GeneralBarrier_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrier *arg1 = (cc::gfx::GeneralBarrier *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_GeneralBarrier_hash_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_gfx_GeneralBarrier_hash_get) + +static bool js_cc_gfx_GeneralBarrier_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::GeneralBarrier *arg1 = (cc::gfx::GeneralBarrier *) NULL ; + cc::gfx::GeneralBarrierInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::GeneralBarrierInfo *) &cc_gfx_GeneralBarrier_info_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_gfx_GeneralBarrier_info_get) + +static bool js_delete_cc_gfx_GeneralBarrier(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_GeneralBarrier) + +bool js_register_cc_gfx_GeneralBarrier(se::Object* obj) { + auto* cls = se::Class::create("GeneralBarrier", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_new_cc_gfx_GeneralBarrier)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hash", _SE(js_cc_gfx_GeneralBarrier_hash_get), nullptr); + cls->defineProperty("info", _SE(js_cc_gfx_GeneralBarrier_info_get), nullptr); + + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_GeneralBarrier_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_GeneralBarrier)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_GeneralBarrier_proto = cls->getProto(); + __jsb_cc_gfx_GeneralBarrier_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Sampler_class = nullptr; +se::Object* __jsb_cc_gfx_Sampler_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Sampler) + +static bool js_new_cc_gfx_Sampler(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::SamplerInfo *arg1 = 0 ; + cc::gfx::SamplerInfo temp1 ; + cc::gfx::Sampler *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::Sampler *)new cc::gfx::Sampler((cc::gfx::SamplerInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_Sampler, __jsb_cc_gfx_Sampler_class, js_delete_cc_gfx_Sampler) + +static bool js_cc_gfx_Sampler_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::SamplerInfo *arg1 = 0 ; + cc::gfx::SamplerInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::Sampler::computeHash((cc::gfx::SamplerInfo const &)*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_FUNC(js_cc_gfx_Sampler_computeHash_static) + +static bool js_cc_gfx_Sampler_unpackFromHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::hash_t arg1 ; + cc::gfx::SamplerInfo result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::gfx::Sampler::unpackFromHash(SWIG_STD_MOVE(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_FUNC(js_cc_gfx_Sampler_unpackFromHash_static) + +static bool js_cc_gfx_Sampler_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Sampler *arg1 = (cc::gfx::Sampler *) NULL ; + cc::gfx::SamplerInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::SamplerInfo *) &cc_gfx_Sampler_info_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_gfx_Sampler_info_get) + +static bool js_cc_gfx_Sampler_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Sampler *arg1 = (cc::gfx::Sampler *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Sampler_hash_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_gfx_Sampler_hash_get) + +static bool js_delete_cc_gfx_Sampler(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Sampler) + +bool js_register_cc_gfx_Sampler(se::Object* obj) { + auto* cls = se::Class::create("Sampler", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_new_cc_gfx_Sampler)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("info", _SE(js_cc_gfx_Sampler_info_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_gfx_Sampler_hash_get), nullptr); + + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_Sampler_computeHash_static)); + cls->defineStaticFunction("unpackFromHash", _SE(js_cc_gfx_Sampler_unpackFromHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Sampler)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Sampler_proto = cls->getProto(); + __jsb_cc_gfx_Sampler_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_TextureBarrier_class = nullptr; +se::Object* __jsb_cc_gfx_TextureBarrier_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrier) + +static bool js_new_cc_gfx_TextureBarrier(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::TextureBarrierInfo *arg1 = 0 ; + cc::gfx::TextureBarrierInfo temp1 ; + cc::gfx::TextureBarrier *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::TextureBarrier *)new cc::gfx::TextureBarrier((cc::gfx::TextureBarrierInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_TextureBarrier, __jsb_cc_gfx_TextureBarrier_class, js_delete_cc_gfx_TextureBarrier) + +static bool js_cc_gfx_TextureBarrier_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::TextureBarrierInfo *arg1 = 0 ; + cc::gfx::TextureBarrierInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::TextureBarrier::computeHash((cc::gfx::TextureBarrierInfo const &)*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_FUNC(js_cc_gfx_TextureBarrier_computeHash_static) + +static bool js_cc_gfx_TextureBarrier_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrier *arg1 = (cc::gfx::TextureBarrier *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_TextureBarrier_hash_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_gfx_TextureBarrier_hash_get) + +static bool js_cc_gfx_TextureBarrier_info_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::TextureBarrier *arg1 = (cc::gfx::TextureBarrier *) NULL ; + cc::gfx::TextureBarrierInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::TextureBarrierInfo *) &cc_gfx_TextureBarrier_info_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_gfx_TextureBarrier_info_get) + +static bool js_delete_cc_gfx_TextureBarrier(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_TextureBarrier) + +bool js_register_cc_gfx_TextureBarrier(se::Object* obj) { + auto* cls = se::Class::create("TextureBarrier", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_new_cc_gfx_TextureBarrier)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("hash", _SE(js_cc_gfx_TextureBarrier_hash_get), nullptr); + cls->defineProperty("info", _SE(js_cc_gfx_TextureBarrier_info_get), nullptr); + + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_TextureBarrier_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_TextureBarrier)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_TextureBarrier_proto = cls->getProto(); + __jsb_cc_gfx_TextureBarrier_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_BufferBarrier_class = nullptr; +se::Object* __jsb_cc_gfx_BufferBarrier_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrier) + +static bool js_cc_gfx_BufferBarrier_computeHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrierInfo *arg1 = 0 ; + cc::gfx::BufferBarrierInfo temp1 ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::gfx::BufferBarrier::computeHash((cc::gfx::BufferBarrierInfo const &)*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_FUNC(js_cc_gfx_BufferBarrier_computeHash_static) + +static bool js_cc_gfx_BufferBarrier_getInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrier *arg1 = (cc::gfx::BufferBarrier *) NULL ; + cc::gfx::BufferBarrierInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferBarrierInfo *) &((cc::gfx::BufferBarrier const *)arg1)->getInfo(); + + 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_gfx_BufferBarrier_getInfo) + +static bool js_cc_gfx_BufferBarrier_getHash(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::BufferBarrier *arg1 = (cc::gfx::BufferBarrier *) NULL ; + ccstd::hash_t *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(s); + if (nullptr == arg1) return true; + result = (ccstd::hash_t *) &((cc::gfx::BufferBarrier const *)arg1)->getHash(); + + 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_gfx_BufferBarrier_getHash) + +static bool js_delete_cc_gfx_BufferBarrier(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_BufferBarrier) + +bool js_register_cc_gfx_BufferBarrier(se::Object* obj) { + auto* cls = se::Class::create("BufferBarrier", obj, __jsb_cc_gfx_GFXObject_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getInfo", _SE(js_cc_gfx_BufferBarrier_getInfo)); + cls->defineFunction("getHash", _SE(js_cc_gfx_BufferBarrier_getHash)); + + + cls->defineStaticFunction("computeHash", _SE(js_cc_gfx_BufferBarrier_computeHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_BufferBarrier)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_BufferBarrier_proto = cls->getProto(); + __jsb_cc_gfx_BufferBarrier_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_Device_class = nullptr; +se::Object* __jsb_cc_gfx_Device_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_Device) + +static bool js_delete_cc_gfx_Device(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_Device) + +static bool js_cc_gfx_Device_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DeviceInfo *arg2 = 0 ; + cc::gfx::DeviceInfo 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(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)(arg1)->initialize((cc::gfx::DeviceInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_initialize) + +static bool js_cc_gfx_Device_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_destroy) + +static bool js_cc_gfx_Device_acquire__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Swapchain **arg2 = (cc::gfx::Swapchain **) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->acquire((cc::gfx::Swapchain *const *)arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_Device_present(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->present(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_present) + +static bool js_cc_gfx_Device_flushCommands__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::CommandBuffer **arg2 = (cc::gfx::CommandBuffer **) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->flushCommands((cc::gfx::CommandBuffer *const *)arg2,arg3); + + + return true; +} + +static bool js_cc_gfx_Device_createCommandBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::CommandBufferInfo *arg2 = 0 ; + cc::gfx::CommandBufferInfo temp2 ; + cc::gfx::CommandBuffer *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(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::gfx::CommandBuffer *)(arg1)->createCommandBuffer((cc::gfx::CommandBufferInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createCommandBuffer) + +static bool js_cc_gfx_Device_createQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueueInfo *arg2 = 0 ; + cc::gfx::QueueInfo temp2 ; + cc::gfx::Queue *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(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::gfx::Queue *)(arg1)->createQueue((cc::gfx::QueueInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createQueue) + +static bool js_cc_gfx_Device_createQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueryPoolInfo *arg2 = 0 ; + cc::gfx::QueryPoolInfo temp2 ; + cc::gfx::QueryPool *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(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::gfx::QueryPool *)(arg1)->createQueryPool((cc::gfx::QueryPoolInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createQueryPool) + +static bool js_cc_gfx_Device_createSwapchain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::SwapchainInfo *arg2 = 0 ; + cc::gfx::SwapchainInfo temp2 ; + cc::gfx::Swapchain *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(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::gfx::Swapchain *)(arg1)->createSwapchain((cc::gfx::SwapchainInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createSwapchain) + +static bool js_cc_gfx_Device_getSwapchains(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::vector< cc::gfx::Swapchain * > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gfx::Swapchain * > *) &((cc::gfx::Device const *)arg1)->getSwapchains(); + + 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_gfx_Device_getSwapchains) + +static bool js_cc_gfx_Device_createShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::ShaderInfo *arg2 = 0 ; + cc::gfx::ShaderInfo temp2 ; + cc::gfx::Shader *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(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::gfx::Shader *)(arg1)->createShader((cc::gfx::ShaderInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createShader) + +static bool js_cc_gfx_Device_createInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::InputAssemblerInfo *arg2 = 0 ; + cc::gfx::InputAssemblerInfo temp2 ; + cc::gfx::InputAssembler *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(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::gfx::InputAssembler *)(arg1)->createInputAssembler((cc::gfx::InputAssemblerInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createInputAssembler) + +static bool js_cc_gfx_Device_createRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::RenderPassInfo *arg2 = 0 ; + cc::gfx::RenderPassInfo temp2 ; + cc::gfx::RenderPass *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(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::gfx::RenderPass *)(arg1)->createRenderPass((cc::gfx::RenderPassInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createRenderPass) + +static bool js_cc_gfx_Device_createFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::FramebufferInfo *arg2 = 0 ; + cc::gfx::FramebufferInfo temp2 ; + cc::gfx::Framebuffer *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(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::gfx::Framebuffer *)(arg1)->createFramebuffer((cc::gfx::FramebufferInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createFramebuffer) + +static bool js_cc_gfx_Device_createDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DescriptorSetInfo *arg2 = 0 ; + cc::gfx::DescriptorSetInfo temp2 ; + cc::gfx::DescriptorSet *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(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::gfx::DescriptorSet *)(arg1)->createDescriptorSet((cc::gfx::DescriptorSetInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createDescriptorSet) + +static bool js_cc_gfx_Device_createDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DescriptorSetLayoutInfo *arg2 = 0 ; + cc::gfx::DescriptorSetLayoutInfo temp2 ; + cc::gfx::DescriptorSetLayout *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(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::gfx::DescriptorSetLayout *)(arg1)->createDescriptorSetLayout((cc::gfx::DescriptorSetLayoutInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createDescriptorSetLayout) + +static bool js_cc_gfx_Device_createPipelineLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::PipelineLayoutInfo *arg2 = 0 ; + cc::gfx::PipelineLayoutInfo temp2 ; + cc::gfx::PipelineLayout *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(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::gfx::PipelineLayout *)(arg1)->createPipelineLayout((cc::gfx::PipelineLayoutInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createPipelineLayout) + +static bool js_cc_gfx_Device_createPipelineState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::PipelineStateInfo *arg2 = 0 ; + cc::gfx::PipelineStateInfo temp2 ; + cc::gfx::PipelineState *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(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::gfx::PipelineState *)(arg1)->createPipelineState((cc::gfx::PipelineStateInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_createPipelineState) + +static bool js_cc_gfx_Device_getSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::SamplerInfo *arg2 = 0 ; + cc::gfx::SamplerInfo temp2 ; + cc::gfx::Sampler *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(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::gfx::Sampler *)(arg1)->getSampler((cc::gfx::SamplerInfo 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_gfx_Device_getSampler) + +static bool js_cc_gfx_Device_getGeneralBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::GeneralBarrierInfo *arg2 = 0 ; + cc::gfx::GeneralBarrierInfo temp2 ; + cc::gfx::GeneralBarrier *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(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::gfx::GeneralBarrier *)(arg1)->getGeneralBarrier((cc::gfx::GeneralBarrierInfo 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_gfx_Device_getGeneralBarrier) + +static bool js_cc_gfx_Device_getTextureBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::TextureBarrierInfo *arg2 = 0 ; + cc::gfx::TextureBarrierInfo temp2 ; + cc::gfx::TextureBarrier *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(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::gfx::TextureBarrier *)(arg1)->getTextureBarrier((cc::gfx::TextureBarrierInfo 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_gfx_Device_getTextureBarrier) + +static bool js_cc_gfx_Device_getBufferBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::BufferBarrierInfo *arg2 = 0 ; + cc::gfx::BufferBarrierInfo temp2 ; + cc::gfx::BufferBarrier *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(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::gfx::BufferBarrier *)(arg1)->getBufferBarrier((cc::gfx::BufferBarrierInfo 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_gfx_Device_getBufferBarrier) + +static bool js_cc_gfx_Device_getQueryPoolResults(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueryPool *arg2 = (cc::gfx::QueryPool *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->getQueryPoolResults(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_getQueryPoolResults) + +static bool js_cc_gfx_Device_flushCommands__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::vector< cc::gfx::CommandBuffer * > *arg2 = 0 ; + ccstd::vector< cc::gfx::CommandBuffer * > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->flushCommands((ccstd::vector< cc::gfx::CommandBuffer * > const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Device_flushCommands(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_Device_flushCommands__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Device_flushCommands__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Device_flushCommands) + +static bool js_cc_gfx_Device_acquire__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::vector< cc::gfx::Swapchain * > *arg2 = 0 ; + ccstd::vector< cc::gfx::Swapchain * > temp2 ; + + arg1 = SE_THIS_OBJECT(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)->acquire((ccstd::vector< cc::gfx::Swapchain * > const &)*arg2); + + + return true; +} + +static bool js_cc_gfx_Device_acquire(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_gfx_Device_acquire__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_Device_acquire__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_Device_acquire) + +static bool js_cc_gfx_Device_getQueryPool(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::QueryPool *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueryPool *)((cc::gfx::Device const *)arg1)->getQueryPool(); + + 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_gfx_Device_getQueryPool) + +static bool js_cc_gfx_Device_hasFeature(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Feature arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((cc::gfx::Device const *)arg1)->hasFeature(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_hasFeature) + +static bool js_cc_gfx_Device_getFormatFeatures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Format arg2 ; + cc::gfx::FormatFeature result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::FormatFeature)((cc::gfx::Device const *)arg1)->getFormatFeatures(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_getFormatFeatures) + +static bool js_cc_gfx_Device_bindingMappingInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::BindingMappingInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BindingMappingInfo *) &((cc::gfx::Device const *)arg1)->bindingMappingInfo(); + + 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_gfx_Device_bindingMappingInfo) + +static bool js_cc_gfx_Device_enableAutoBarrier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableAutoBarrier(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_enableAutoBarrier) + +static bool js_cc_gfx_Device_getMaxSampleCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Format arg2 ; + cc::gfx::TextureUsage arg3 ; + cc::gfx::TextureFlags arg4 ; + cc::gfx::SampleCount result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::SampleCount)((cc::gfx::Device const *)arg1)->getMaxSampleCount(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gfx_Device_getMaxSampleCount) + +static bool js_cc_gfx_Device_gfxAPI_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::API result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::API)cc_gfx_Device_gfxAPI_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_gfx_Device_gfxAPI_get) + +static bool js_cc_gfx_Device_deviceName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Device_deviceName_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_gfx_Device_deviceName_get) + +static bool js_cc_gfx_Device_memoryStatus_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::MemoryStatus *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::MemoryStatus *) &cc_gfx_Device_memoryStatus_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_gfx_Device_memoryStatus_get) + +static bool js_cc_gfx_Device_queue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::Queue *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Queue *)cc_gfx_Device_queue_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_gfx_Device_queue_get) + +static bool js_cc_gfx_Device_commandBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::CommandBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::CommandBuffer *)cc_gfx_Device_commandBuffer_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_gfx_Device_commandBuffer_get) + +static bool js_cc_gfx_Device_renderer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Device_renderer_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_gfx_Device_renderer_get) + +static bool js_cc_gfx_Device_vendor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_gfx_Device_vendor_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_gfx_Device_vendor_get) + +static bool js_cc_gfx_Device_numDrawCalls_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Device_numDrawCalls_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Device_numDrawCalls_get) + +static bool js_cc_gfx_Device_numInstances_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Device_numInstances_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Device_numInstances_get) + +static bool js_cc_gfx_Device_numTris_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gfx_Device_numTris_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gfx_Device_numTris_get) + +static bool js_cc_gfx_Device_capabilities_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::gfx::DeviceCaps *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DeviceCaps *) &cc_gfx_Device_capabilities_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_gfx_Device_capabilities_get) + +bool js_register_cc_gfx_Device(se::Object* obj) { + auto* cls = se::Class::create("Device", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("gfxAPI", _SE(js_cc_gfx_Device_gfxAPI_get), nullptr); + cls->defineProperty("deviceName", _SE(js_cc_gfx_Device_deviceName_get), nullptr); + cls->defineProperty("memoryStatus", _SE(js_cc_gfx_Device_memoryStatus_get), nullptr); + cls->defineProperty("queue", _SE(js_cc_gfx_Device_queue_get), nullptr); + cls->defineProperty("commandBuffer", _SE(js_cc_gfx_Device_commandBuffer_get), nullptr); + cls->defineProperty("renderer", _SE(js_cc_gfx_Device_renderer_get), nullptr); + cls->defineProperty("vendor", _SE(js_cc_gfx_Device_vendor_get), nullptr); + cls->defineProperty("numDrawCalls", _SE(js_cc_gfx_Device_numDrawCalls_get), nullptr); + cls->defineProperty("numInstances", _SE(js_cc_gfx_Device_numInstances_get), nullptr); + cls->defineProperty("numTris", _SE(js_cc_gfx_Device_numTris_get), nullptr); + cls->defineProperty("capabilities", _SE(js_cc_gfx_Device_capabilities_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_gfx_Device_initialize)); + cls->defineFunction("destroy", _SE(js_cc_gfx_Device_destroy)); + cls->defineFunction("present", _SE(js_cc_gfx_Device_present)); + cls->defineFunction("createCommandBuffer", _SE(js_cc_gfx_Device_createCommandBuffer)); + cls->defineFunction("createQueue", _SE(js_cc_gfx_Device_createQueue)); + cls->defineFunction("createQueryPool", _SE(js_cc_gfx_Device_createQueryPool)); + cls->defineFunction("createSwapchain", _SE(js_cc_gfx_Device_createSwapchain)); + cls->defineFunction("getSwapchains", _SE(js_cc_gfx_Device_getSwapchains)); + cls->defineFunction("createShader", _SE(js_cc_gfx_Device_createShader)); + cls->defineFunction("createInputAssembler", _SE(js_cc_gfx_Device_createInputAssembler)); + cls->defineFunction("createRenderPass", _SE(js_cc_gfx_Device_createRenderPass)); + cls->defineFunction("createFramebuffer", _SE(js_cc_gfx_Device_createFramebuffer)); + cls->defineFunction("createDescriptorSet", _SE(js_cc_gfx_Device_createDescriptorSet)); + cls->defineFunction("createDescriptorSetLayout", _SE(js_cc_gfx_Device_createDescriptorSetLayout)); + cls->defineFunction("createPipelineLayout", _SE(js_cc_gfx_Device_createPipelineLayout)); + cls->defineFunction("createPipelineState", _SE(js_cc_gfx_Device_createPipelineState)); + cls->defineFunction("getSampler", _SE(js_cc_gfx_Device_getSampler)); + cls->defineFunction("getGeneralBarrier", _SE(js_cc_gfx_Device_getGeneralBarrier)); + cls->defineFunction("getTextureBarrier", _SE(js_cc_gfx_Device_getTextureBarrier)); + cls->defineFunction("getBufferBarrier", _SE(js_cc_gfx_Device_getBufferBarrier)); + cls->defineFunction("getQueryPoolResults", _SE(js_cc_gfx_Device_getQueryPoolResults)); + cls->defineFunction("flushCommands", _SE(js_cc_gfx_Device_flushCommands)); + cls->defineFunction("acquire", _SE(js_cc_gfx_Device_acquire)); + cls->defineFunction("getQueryPool", _SE(js_cc_gfx_Device_getQueryPool)); + cls->defineFunction("hasFeature", _SE(js_cc_gfx_Device_hasFeature)); + cls->defineFunction("getFormatFeatures", _SE(js_cc_gfx_Device_getFormatFeatures)); + cls->defineFunction("bindingMappingInfo", _SE(js_cc_gfx_Device_bindingMappingInfo)); + cls->defineFunction("enableAutoBarrier", _SE(js_cc_gfx_Device_enableAutoBarrier)); + cls->defineFunction("getMaxSampleCount", _SE(js_cc_gfx_Device_getMaxSampleCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_Device)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_Device_proto = cls->getProto(); + __jsb_cc_gfx_Device_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gfx_DeviceManager_class = nullptr; +se::Object* __jsb_cc_gfx_DeviceManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gfx_DeviceManager) + +static bool js_cc_gfx_DeviceManager_create_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::Device *result = 0 ; + + result = (cc::gfx::Device *)cc::gfx::DeviceManager::create(); + + 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_gfx_DeviceManager_create_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gfx::DeviceInfo *arg1 = 0 ; + cc::gfx::DeviceInfo temp1 ; + cc::gfx::Device *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gfx::Device *)cc::gfx::DeviceManager::create((cc::gfx::DeviceInfo const &)*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; +} + +static bool js_cc_gfx_DeviceManager_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_gfx_DeviceManager_create_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_gfx_DeviceManager_create_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gfx_DeviceManager_create_static) + +static bool js_new_cc_gfx_DeviceManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gfx::DeviceManager *result; + result = (cc::gfx::DeviceManager *)new cc::gfx::DeviceManager(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gfx_DeviceManager, __jsb_cc_gfx_DeviceManager_class, js_delete_cc_gfx_DeviceManager) + +static bool js_delete_cc_gfx_DeviceManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gfx_DeviceManager) + +bool js_register_cc_gfx_DeviceManager(se::Object* obj) { + auto* cls = se::Class::create("DeviceManager", obj, nullptr, _SE(js_new_cc_gfx_DeviceManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("create", _SE(js_cc_gfx_DeviceManager_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gfx_DeviceManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gfx_DeviceManager_proto = cls->getProto(); + __jsb_cc_gfx_DeviceManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_gfx(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("gfx", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("gfx", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_gfx_Size(ns); + js_register_cc_gfx_DeviceCaps(ns); + js_register_cc_gfx_DeviceOptions(ns); + js_register_cc_gfx_Offset(ns); + js_register_cc_gfx_Rect(ns); + js_register_cc_gfx_Extent(ns); + js_register_cc_gfx_TextureSubresLayers(ns); + js_register_cc_gfx_TextureSubresRange(ns); + js_register_cc_gfx_TextureCopy(ns); + js_register_cc_gfx_TextureBlit(ns); + js_register_cc_gfx_BufferTextureCopy(ns); + js_register_cc_gfx_Viewport(ns); + js_register_cc_gfx_Color(ns); + js_register_cc_gfx_MarkerInfo(ns); + js_register_cc_gfx_BindingMappingInfo(ns); + js_register_cc_gfx_SwapchainInfo(ns); + js_register_cc_gfx_DeviceInfo(ns); + js_register_cc_gfx_BufferInfo(ns); + js_register_cc_gfx_BufferViewInfo(ns); + js_register_cc_gfx_DrawInfo(ns); + js_register_cc_gfx_DispatchInfo(ns); + js_register_cc_gfx_IndirectBuffer(ns); + js_register_cc_gfx_TextureInfo(ns); + js_register_cc_gfx_TextureViewInfo(ns); + js_register_cc_gfx_SamplerInfo(ns); + js_register_cc_gfx_Uniform(ns); + js_register_cc_gfx_UniformBlock(ns); + js_register_cc_gfx_UniformSamplerTexture(ns); + js_register_cc_gfx_UniformSampler(ns); + js_register_cc_gfx_UniformTexture(ns); + js_register_cc_gfx_UniformStorageImage(ns); + js_register_cc_gfx_UniformStorageBuffer(ns); + js_register_cc_gfx_UniformInputAttachment(ns); + js_register_cc_gfx_ShaderStage(ns); + js_register_cc_gfx_Attribute(ns); + js_register_cc_gfx_ShaderInfo(ns); + js_register_cc_gfx_InputAssemblerInfo(ns); + js_register_cc_gfx_ColorAttachment(ns); + js_register_cc_gfx_DepthStencilAttachment(ns); + js_register_cc_gfx_SubpassInfo(ns); + js_register_cc_gfx_SubpassDependency(ns); + js_register_cc_gfx_RenderPassInfo(ns); + js_register_cc_gfx_ResourceRange(ns); + js_register_cc_gfx_GeneralBarrierInfo(ns); + js_register_cc_gfx_TextureBarrierInfo(ns); + js_register_cc_gfx_BufferBarrierInfo(ns); + js_register_cc_gfx_FramebufferInfo(ns); + js_register_cc_gfx_DescriptorSetLayoutBinding(ns); + js_register_cc_gfx_DescriptorSetLayoutInfo(ns); + js_register_cc_gfx_DescriptorSetInfo(ns); + js_register_cc_gfx_PipelineLayoutInfo(ns); + js_register_cc_gfx_InputState(ns); + js_register_cc_gfx_RasterizerState(ns); + js_register_cc_gfx_DepthStencilState(ns); + js_register_cc_gfx_BlendTarget(ns); + js_register_cc_gfx_BlendState(ns); + js_register_cc_gfx_PipelineStateInfo(ns); + js_register_cc_gfx_CommandBufferInfo(ns); + js_register_cc_gfx_QueueInfo(ns); + js_register_cc_gfx_QueryPoolInfo(ns); + js_register_cc_gfx_FormatInfo(ns); + js_register_cc_gfx_MemoryStatus(ns); + js_register_cc_gfx_DynamicStencilStates(ns); + js_register_cc_gfx_DynamicStates(ns); + js_register_cc_gfx_GFXObject(ns); + js_register_cc_gfx_Buffer(ns); + js_register_cc_gfx_CommandBuffer(ns); + js_register_cc_gfx_DescriptorSet(ns); + js_register_cc_gfx_DescriptorSetLayout(ns); + js_register_cc_gfx_Framebuffer(ns); + js_register_cc_gfx_InputAssembler(ns); + js_register_cc_gfx_PipelineLayout(ns); + js_register_cc_gfx_PipelineState(ns); + js_register_cc_gfx_QueryPool(ns); + js_register_cc_gfx_Queue(ns); + js_register_cc_gfx_RenderPass(ns); + js_register_cc_gfx_Shader(ns); + js_register_cc_gfx_Swapchain(ns); + js_register_cc_gfx_Texture(ns); + js_register_cc_gfx_GeneralBarrier(ns); + js_register_cc_gfx_Sampler(ns); + js_register_cc_gfx_TextureBarrier(ns); + js_register_cc_gfx_BufferBarrier(ns); + js_register_cc_gfx_Device(ns); + js_register_cc_gfx_DeviceManager(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_gfx_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gfx_auto.h new file mode 100644 index 0000000000..5e44187b91 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gfx_auto.h @@ -0,0 +1,725 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "renderer/GFXDeviceManager.h" + + + +bool register_all_gfx(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Size); +extern se::Object *__jsb_cc_gfx_Size_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Size_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Size * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceCaps); +extern se::Object *__jsb_cc_gfx_DeviceCaps_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceCaps_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceCaps * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceOptions); +extern se::Object *__jsb_cc_gfx_DeviceOptions_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceOptions_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceOptions * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Offset); +extern se::Object *__jsb_cc_gfx_Offset_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Offset_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Offset * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Rect); +extern se::Object *__jsb_cc_gfx_Rect_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Rect_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Rect * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Extent); +extern se::Object *__jsb_cc_gfx_Extent_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Extent_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Extent * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureSubresLayers); +extern se::Object *__jsb_cc_gfx_TextureSubresLayers_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureSubresLayers_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresLayers * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureSubresRange); +extern se::Object *__jsb_cc_gfx_TextureSubresRange_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureSubresRange_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureSubresRange * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureCopy); +extern se::Object *__jsb_cc_gfx_TextureCopy_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureCopy_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureCopy * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureBlit); +extern se::Object *__jsb_cc_gfx_TextureBlit_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureBlit_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBlit * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferTextureCopy); +extern se::Object *__jsb_cc_gfx_BufferTextureCopy_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferTextureCopy_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferTextureCopy * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Viewport); +extern se::Object *__jsb_cc_gfx_Viewport_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Viewport_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Viewport * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Color); +extern se::Object *__jsb_cc_gfx_Color_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Color_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Color * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::MarkerInfo); +extern se::Object *__jsb_cc_gfx_MarkerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_MarkerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MarkerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BindingMappingInfo); +extern se::Object *__jsb_cc_gfx_BindingMappingInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BindingMappingInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BindingMappingInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SwapchainInfo); +extern se::Object *__jsb_cc_gfx_SwapchainInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SwapchainInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SwapchainInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceInfo); +extern se::Object *__jsb_cc_gfx_DeviceInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DeviceInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferInfo); +extern se::Object *__jsb_cc_gfx_BufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferViewInfo); +extern se::Object *__jsb_cc_gfx_BufferViewInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferViewInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferViewInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DrawInfo); +extern se::Object *__jsb_cc_gfx_DrawInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DrawInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DrawInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DispatchInfo); +extern se::Object *__jsb_cc_gfx_DispatchInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DispatchInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DispatchInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::IndirectBuffer); +extern se::Object *__jsb_cc_gfx_IndirectBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_IndirectBuffer_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::IndirectBuffer * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureInfo); +extern se::Object *__jsb_cc_gfx_TextureInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureViewInfo); +extern se::Object *__jsb_cc_gfx_TextureViewInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureViewInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureViewInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SamplerInfo); +extern se::Object *__jsb_cc_gfx_SamplerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SamplerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SamplerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Uniform); +extern se::Object *__jsb_cc_gfx_Uniform_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Uniform_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Uniform * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformBlock); +extern se::Object *__jsb_cc_gfx_UniformBlock_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformBlock_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformBlock * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformSamplerTexture); +extern se::Object *__jsb_cc_gfx_UniformSamplerTexture_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformSamplerTexture_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSamplerTexture * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformSampler); +extern se::Object *__jsb_cc_gfx_UniformSampler_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformSampler_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformSampler * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformTexture); +extern se::Object *__jsb_cc_gfx_UniformTexture_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformTexture_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformTexture * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformStorageImage); +extern se::Object *__jsb_cc_gfx_UniformStorageImage_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformStorageImage_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageImage * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformStorageBuffer); +extern se::Object *__jsb_cc_gfx_UniformStorageBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformStorageBuffer_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformStorageBuffer * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::UniformInputAttachment); +extern se::Object *__jsb_cc_gfx_UniformInputAttachment_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_UniformInputAttachment_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::UniformInputAttachment * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ShaderStage); +extern se::Object *__jsb_cc_gfx_ShaderStage_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ShaderStage_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderStage * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Attribute); +extern se::Object *__jsb_cc_gfx_Attribute_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Attribute_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::Attribute * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ShaderInfo); +extern se::Object *__jsb_cc_gfx_ShaderInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ShaderInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ShaderInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::InputAssemblerInfo); +extern se::Object *__jsb_cc_gfx_InputAssemblerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_InputAssemblerInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputAssemblerInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ColorAttachment); +extern se::Object *__jsb_cc_gfx_ColorAttachment_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ColorAttachment_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ColorAttachment * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DepthStencilAttachment); +extern se::Object *__jsb_cc_gfx_DepthStencilAttachment_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DepthStencilAttachment_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilAttachment * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SubpassInfo); +extern se::Object *__jsb_cc_gfx_SubpassInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SubpassInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::SubpassDependency); +extern se::Object *__jsb_cc_gfx_SubpassDependency_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_SubpassDependency_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::SubpassDependency * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::RenderPassInfo); +extern se::Object *__jsb_cc_gfx_RenderPassInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_RenderPassInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RenderPassInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::ResourceRange); +extern se::Object *__jsb_cc_gfx_ResourceRange_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_ResourceRange_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::ResourceRange * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::GeneralBarrierInfo); +extern se::Object *__jsb_cc_gfx_GeneralBarrierInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_GeneralBarrierInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::GeneralBarrierInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureBarrierInfo); +extern se::Object *__jsb_cc_gfx_TextureBarrierInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureBarrierInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::TextureBarrierInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferBarrierInfo); +extern se::Object *__jsb_cc_gfx_BufferBarrierInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferBarrierInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BufferBarrierInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::FramebufferInfo); +extern se::Object *__jsb_cc_gfx_FramebufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_FramebufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FramebufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetLayoutBinding); +extern se::Object *__jsb_cc_gfx_DescriptorSetLayoutBinding_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetLayoutBinding_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutBinding * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetLayoutInfo); +extern se::Object *__jsb_cc_gfx_DescriptorSetLayoutInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetLayoutInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetLayoutInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetInfo); +extern se::Object *__jsb_cc_gfx_DescriptorSetInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DescriptorSetInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineLayoutInfo); +extern se::Object *__jsb_cc_gfx_PipelineLayoutInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineLayoutInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineLayoutInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::InputState); +extern se::Object *__jsb_cc_gfx_InputState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_InputState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::InputState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::RasterizerState); +extern se::Object *__jsb_cc_gfx_RasterizerState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_RasterizerState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::RasterizerState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DepthStencilState); +extern se::Object *__jsb_cc_gfx_DepthStencilState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DepthStencilState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DepthStencilState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BlendTarget); +extern se::Object *__jsb_cc_gfx_BlendTarget_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BlendTarget_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendTarget * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BlendState); +extern se::Object *__jsb_cc_gfx_BlendState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BlendState_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::BlendState * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineStateInfo); +extern se::Object *__jsb_cc_gfx_PipelineStateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineStateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::PipelineStateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::CommandBufferInfo); +extern se::Object *__jsb_cc_gfx_CommandBufferInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_CommandBufferInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::CommandBufferInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::QueueInfo); +extern se::Object *__jsb_cc_gfx_QueueInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_QueueInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueueInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::QueryPoolInfo); +extern se::Object *__jsb_cc_gfx_QueryPoolInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_QueryPoolInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::QueryPoolInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::FormatInfo); +extern se::Object *__jsb_cc_gfx_FormatInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_FormatInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::FormatInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::MemoryStatus); +extern se::Object *__jsb_cc_gfx_MemoryStatus_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_MemoryStatus_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::MemoryStatus * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DynamicStencilStates); +extern se::Object *__jsb_cc_gfx_DynamicStencilStates_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DynamicStencilStates_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStencilStates * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DynamicStates); +extern se::Object *__jsb_cc_gfx_DynamicStates_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DynamicStates_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gfx::DynamicStates * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::GFXObject); +extern se::Object *__jsb_cc_gfx_GFXObject_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_GFXObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Buffer); +extern se::Object *__jsb_cc_gfx_Buffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Buffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::CommandBuffer); +extern se::Object *__jsb_cc_gfx_CommandBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_CommandBuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSet); +extern se::Object *__jsb_cc_gfx_DescriptorSet_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSet_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DescriptorSetLayout); +extern se::Object *__jsb_cc_gfx_DescriptorSetLayout_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DescriptorSetLayout_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Framebuffer); +extern se::Object *__jsb_cc_gfx_Framebuffer_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Framebuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::InputAssembler); +extern se::Object *__jsb_cc_gfx_InputAssembler_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_InputAssembler_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineLayout); +extern se::Object *__jsb_cc_gfx_PipelineLayout_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineLayout_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::PipelineState); +extern se::Object *__jsb_cc_gfx_PipelineState_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_PipelineState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::QueryPool); +extern se::Object *__jsb_cc_gfx_QueryPool_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_QueryPool_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Queue); +extern se::Object *__jsb_cc_gfx_Queue_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Queue_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::RenderPass); +extern se::Object *__jsb_cc_gfx_RenderPass_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_RenderPass_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Shader); +extern se::Object *__jsb_cc_gfx_Shader_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Shader_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Swapchain); +extern se::Object *__jsb_cc_gfx_Swapchain_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Swapchain_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Texture); +extern se::Object *__jsb_cc_gfx_Texture_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Texture_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::GeneralBarrier); +extern se::Object *__jsb_cc_gfx_GeneralBarrier_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_GeneralBarrier_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Sampler); +extern se::Object *__jsb_cc_gfx_Sampler_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Sampler_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::TextureBarrier); +extern se::Object *__jsb_cc_gfx_TextureBarrier_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_TextureBarrier_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::BufferBarrier); +extern se::Object *__jsb_cc_gfx_BufferBarrier_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_BufferBarrier_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::Device); +extern se::Object *__jsb_cc_gfx_Device_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_Device_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceManager); +extern se::Object *__jsb_cc_gfx_DeviceManager_proto; // NOLINT +extern se::Class * __jsb_cc_gfx_DeviceManager_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_gi_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gi_auto.cpp new file mode 100644 index 0000000000..316f13d740 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gi_auto.cpp @@ -0,0 +1,3484 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_geometry_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gi_auto.h" + +using namespace cc; +using namespace cc::gi; + + +#define cc_gi_LightProbesData_probes_get(self_) self_->getProbes() +#define cc_gi_LightProbesData_probes_set(self_, val_) self_->setProbes(val_) + + +#define cc_gi_LightProbesData_tetrahedrons_get(self_) self_->getTetrahedrons() +#define cc_gi_LightProbesData_tetrahedrons_set(self_, val_) self_->setTetrahedrons(val_) + + +#define cc_gi_LightProbes_giScale_get(self_) self_->getGIScale() +#define cc_gi_LightProbes_giScale_set(self_, val_) self_->setGIScale(val_) + + +#define cc_gi_LightProbes_giSamples_get(self_) self_->getGISamples() +#define cc_gi_LightProbes_giSamples_set(self_, val_) self_->setGISamples(val_) + + +#define cc_gi_LightProbes_bounces_get(self_) self_->getBounces() +#define cc_gi_LightProbes_bounces_set(self_, val_) self_->setBounces(val_) + + +#define cc_gi_LightProbes_reduceRinging_get(self_) self_->getReduceRinging() +#define cc_gi_LightProbes_reduceRinging_set(self_, val_) self_->setReduceRinging(val_) + + +#define cc_gi_LightProbes_showProbe_get(self_) self_->isShowProbe() +#define cc_gi_LightProbes_showProbe_set(self_, val_) self_->setShowProbe(val_) + + +#define cc_gi_LightProbes_showWireframe_get(self_) self_->isShowWireframe() +#define cc_gi_LightProbes_showWireframe_set(self_, val_) self_->setShowWireframe(val_) + + +#define cc_gi_LightProbes_lightProbeSphereVolume_get(self_) self_->getLightProbeSphereVolume() +#define cc_gi_LightProbes_lightProbeSphereVolume_set(self_, val_) self_->setLightProbeSphereVolume(val_) + + +#define cc_gi_LightProbes_showConvex_get(self_) self_->isShowConvex() +#define cc_gi_LightProbes_showConvex_set(self_, val_) self_->setShowConvex(val_) + + +#define cc_gi_LightProbes_data_get(self_) self_->getData() +#define cc_gi_LightProbes_data_set(self_, val_) self_->setData(val_) + + +#define cc_gi_LightProbeInfo_giScale_get(self_) self_->getGIScale() +#define cc_gi_LightProbeInfo_giScale_set(self_, val_) self_->setGIScale(val_) + + +#define cc_gi_LightProbeInfo_giSamples_get(self_) self_->getGISamples() +#define cc_gi_LightProbeInfo_giSamples_set(self_, val_) self_->setGISamples(val_) + + +#define cc_gi_LightProbeInfo_bounces_get(self_) self_->getBounces() +#define cc_gi_LightProbeInfo_bounces_set(self_, val_) self_->setBounces(val_) + + +#define cc_gi_LightProbeInfo_lightProbeSphereVolume_get(self_) self_->getLightProbeSphereVolume() +#define cc_gi_LightProbeInfo_lightProbeSphereVolume_set(self_, val_) self_->setLightProbeSphereVolume(val_) + + +#define cc_gi_LightProbeInfo_reduceRinging_get(self_) self_->getReduceRinging() +#define cc_gi_LightProbeInfo_reduceRinging_set(self_, val_) self_->setReduceRinging(val_) + + +#define cc_gi_LightProbeInfo_showProbe_get(self_) self_->isShowProbe() +#define cc_gi_LightProbeInfo_showProbe_set(self_, val_) self_->setShowProbe(val_) + + +#define cc_gi_LightProbeInfo_showWireframe_get(self_) self_->isShowWireframe() +#define cc_gi_LightProbeInfo_showWireframe_set(self_, val_) self_->setShowWireframe(val_) + + +#define cc_gi_LightProbeInfo_showConvex_get(self_) self_->isShowConvex() +#define cc_gi_LightProbeInfo_showConvex_set(self_, val_) self_->setShowConvex(val_) + + +#define cc_gi_LightProbeInfo_data_get(self_) self_->getData() +#define cc_gi_LightProbeInfo_data_set(self_, val_) self_->setData(val_) + + + +se::Class* __jsb_cc_gi_Vertex_class = nullptr; +se::Object* __jsb_cc_gi_Vertex_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Vertex) + +static bool js_cc_gi_Vertex_coefficients_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->coefficients, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Vertex_coefficients_set) + +static bool js_cc_gi_Vertex_coefficients_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->coefficients, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->coefficients, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Vertex_coefficients_get) + +static bool js_cc_gi_Vertex_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->position, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Vertex_position_set) + +static bool js_cc_gi_Vertex_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->position, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->position, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Vertex_position_get) + +static bool js_cc_gi_Vertex_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Vertex_normal_set) + +static bool js_cc_gi_Vertex_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Vertex *arg1 = (cc::gi::Vertex *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Vertex_normal_get) + +static bool js_new_cc_gi_Vertex__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Vertex *result; + result = (cc::gi::Vertex *)new cc::gi::Vertex(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Vertex__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + Vec3 *arg1 = 0 ; + Vec3 temp1 ; + cc::gi::Vertex *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gi::Vertex *)new cc::gi::Vertex((Vec3 const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Vertex(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_gi_Vertex__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_gi_Vertex__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Vertex"); + return false; +} +SE_BIND_CTOR(js_new_cc_gi_Vertex, __jsb_cc_gi_Vertex_class, js_delete_cc_gi_Vertex) + +static bool js_delete_cc_gi_Vertex(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Vertex) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Vertex * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("coefficients", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->coefficients), ctx); + } + + + json->getProperty("position", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->position), ctx); + } + + + json->getProperty("normal", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->normal), ctx); + } + + + return ok; +} + + +bool js_register_cc_gi_Vertex(se::Object* obj) { + auto* cls = se::Class::create("Vertex", obj, nullptr, _SE(js_new_cc_gi_Vertex)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("coefficients", _SE(js_cc_gi_Vertex_coefficients_get), _SE(js_cc_gi_Vertex_coefficients_set)); + cls->defineProperty("position", _SE(js_cc_gi_Vertex_position_get), _SE(js_cc_gi_Vertex_position_set)); + cls->defineProperty("normal", _SE(js_cc_gi_Vertex_normal_get), _SE(js_cc_gi_Vertex_normal_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Vertex)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_Vertex_proto = cls->getProto(); + __jsb_cc_gi_Vertex_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_CircumSphere_class = nullptr; +se::Object* __jsb_cc_gi_CircumSphere_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_CircumSphere) + +static bool js_cc_gi_CircumSphere_radiusSquared_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->radiusSquared, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_CircumSphere_radiusSquared_set) + +static bool js_cc_gi_CircumSphere_radiusSquared_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->radiusSquared, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_CircumSphere_radiusSquared_get) + +static bool js_cc_gi_CircumSphere_center_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->center, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_CircumSphere_center_set) + +static bool js_cc_gi_CircumSphere_center_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->center, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->center, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_CircumSphere_center_get) + +static bool js_new_cc_gi_CircumSphere(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::CircumSphere *result; + result = (cc::gi::CircumSphere *)new cc::gi::CircumSphere(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_CircumSphere, __jsb_cc_gi_CircumSphere_class, js_delete_cc_gi_CircumSphere) + +static bool js_cc_gi_CircumSphere_init(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::CircumSphere *arg1 = (cc::gi::CircumSphere *) NULL ; + Vec3 *arg2 = 0 ; + Vec3 *arg3 = 0 ; + Vec3 *arg4 = 0 ; + Vec3 *arg5 = 0 ; + Vec3 temp2 ; + Vec3 temp3 ; + Vec3 temp4 ; + Vec3 temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->init((Vec3 const &)*arg2,(Vec3 const &)*arg3,(Vec3 const &)*arg4,(Vec3 const &)*arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_CircumSphere_init) + +static bool js_delete_cc_gi_CircumSphere(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_CircumSphere) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::CircumSphere * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("radiusSquared", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->radiusSquared), ctx); + } + + + json->getProperty("center", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->center), ctx); + } + + + return ok; +} + + +bool js_register_cc_gi_CircumSphere(se::Object* obj) { + auto* cls = se::Class::create("CircumSphere", obj, nullptr, _SE(js_new_cc_gi_CircumSphere)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("radiusSquared", _SE(js_cc_gi_CircumSphere_radiusSquared_get), _SE(js_cc_gi_CircumSphere_radiusSquared_set)); + cls->defineProperty("center", _SE(js_cc_gi_CircumSphere_center_get), _SE(js_cc_gi_CircumSphere_center_set)); + + cls->defineFunction("init", _SE(js_cc_gi_CircumSphere_init)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_CircumSphere)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_CircumSphere_proto = cls->getProto(); + __jsb_cc_gi_CircumSphere_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_Tetrahedron_class = nullptr; +se::Object* __jsb_cc_gi_Tetrahedron_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Tetrahedron) + +static bool js_cc_gi_Tetrahedron_invalid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->invalid); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_invalid_set) + +static bool js_cc_gi_Tetrahedron_invalid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->invalid, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_invalid_get) + +static bool js_cc_gi_Tetrahedron_vertex0_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex0, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex0_set) + +static bool js_cc_gi_Tetrahedron_vertex0_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex0, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex0_get) + +static bool js_cc_gi_Tetrahedron_vertex1_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex1_set) + +static bool js_cc_gi_Tetrahedron_vertex1_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex1, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex1_get) + +static bool js_cc_gi_Tetrahedron_vertex2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex2_set) + +static bool js_cc_gi_Tetrahedron_vertex2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex2, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex2_get) + +static bool js_cc_gi_Tetrahedron_vertex3_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vertex3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_vertex3_set) + +static bool js_cc_gi_Tetrahedron_vertex3_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vertex3, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_vertex3_get) + +static bool js_cc_gi_Tetrahedron_neighbours_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->neighbours, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_neighbours_set) + +static bool js_cc_gi_Tetrahedron_neighbours_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->neighbours, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->neighbours, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_neighbours_get) + +static bool js_cc_gi_Tetrahedron_matrix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->matrix, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_matrix_set) + +static bool js_cc_gi_Tetrahedron_matrix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->matrix, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->matrix, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_matrix_get) + +static bool js_cc_gi_Tetrahedron_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_offset_set) + +static bool js_cc_gi_Tetrahedron_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->offset, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_offset_get) + +static bool js_cc_gi_Tetrahedron_sphere_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sphere, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_Tetrahedron_sphere_set) + +static bool js_cc_gi_Tetrahedron_sphere_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sphere, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sphere, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_Tetrahedron_sphere_get) + +static bool js_new_cc_gi_Tetrahedron__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ; + int32_t arg2 ; + int32_t arg3 ; + int32_t arg4 ; + int32_t arg5 ; + cc::gi::Tetrahedron *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron((cc::gi::Delaunay const *)arg1,arg2,arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Tetrahedron__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ; + int32_t arg2 ; + int32_t arg3 ; + int32_t arg4 ; + cc::gi::Tetrahedron *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron((cc::gi::Delaunay const *)arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Tetrahedron__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::gi::Tetrahedron *result; + result = (cc::gi::Tetrahedron *)new cc::gi::Tetrahedron(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_gi_Tetrahedron(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 5) { + ret = js_new_cc_gi_Tetrahedron__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_gi_Tetrahedron__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_gi_Tetrahedron__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Tetrahedron"); + return false; +} +SE_BIND_CTOR(js_new_cc_gi_Tetrahedron, __jsb_cc_gi_Tetrahedron_class, js_delete_cc_gi_Tetrahedron) + +static bool js_cc_gi_Tetrahedron_isInCircumSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + Vec3 *arg2 = 0 ; + Vec3 temp2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)((cc::gi::Tetrahedron const *)arg1)->isInCircumSphere((Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_isInCircumSphere) + +static bool js_cc_gi_Tetrahedron_contain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + int32_t arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((cc::gi::Tetrahedron const *)arg1)->contain(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_contain) + +static bool js_cc_gi_Tetrahedron_isInnerTetrahedron(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::Tetrahedron const *)arg1)->isInnerTetrahedron(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_isInnerTetrahedron) + +static bool js_cc_gi_Tetrahedron_isOuterCell(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Tetrahedron *arg1 = (cc::gi::Tetrahedron *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::Tetrahedron const *)arg1)->isOuterCell(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Tetrahedron_isOuterCell) + +static bool js_delete_cc_gi_Tetrahedron(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Tetrahedron) + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Tetrahedron * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("invalid", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->invalid), ctx); + } + + + json->getProperty("vertex0", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex0), ctx); + } + + + json->getProperty("vertex1", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex1), ctx); + } + + + json->getProperty("vertex2", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex2), ctx); + } + + + json->getProperty("vertex3", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vertex3), ctx); + } + + + json->getProperty("neighbours", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->neighbours), ctx); + } + + + json->getProperty("matrix", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->matrix), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + json->getProperty("sphere", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sphere), ctx); + } + + + return ok; +} + + +bool js_register_cc_gi_Tetrahedron(se::Object* obj) { + auto* cls = se::Class::create("Tetrahedron", obj, nullptr, _SE(js_new_cc_gi_Tetrahedron)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("invalid", _SE(js_cc_gi_Tetrahedron_invalid_get), _SE(js_cc_gi_Tetrahedron_invalid_set)); + cls->defineProperty("vertex0", _SE(js_cc_gi_Tetrahedron_vertex0_get), _SE(js_cc_gi_Tetrahedron_vertex0_set)); + cls->defineProperty("vertex1", _SE(js_cc_gi_Tetrahedron_vertex1_get), _SE(js_cc_gi_Tetrahedron_vertex1_set)); + cls->defineProperty("vertex2", _SE(js_cc_gi_Tetrahedron_vertex2_get), _SE(js_cc_gi_Tetrahedron_vertex2_set)); + cls->defineProperty("vertex3", _SE(js_cc_gi_Tetrahedron_vertex3_get), _SE(js_cc_gi_Tetrahedron_vertex3_set)); + cls->defineProperty("neighbours", _SE(js_cc_gi_Tetrahedron_neighbours_get), _SE(js_cc_gi_Tetrahedron_neighbours_set)); + cls->defineProperty("matrix", _SE(js_cc_gi_Tetrahedron_matrix_get), _SE(js_cc_gi_Tetrahedron_matrix_set)); + cls->defineProperty("offset", _SE(js_cc_gi_Tetrahedron_offset_get), _SE(js_cc_gi_Tetrahedron_offset_set)); + cls->defineProperty("sphere", _SE(js_cc_gi_Tetrahedron_sphere_get), _SE(js_cc_gi_Tetrahedron_sphere_set)); + + cls->defineFunction("isInCircumSphere", _SE(js_cc_gi_Tetrahedron_isInCircumSphere)); + cls->defineFunction("contain", _SE(js_cc_gi_Tetrahedron_contain)); + cls->defineFunction("isInnerTetrahedron", _SE(js_cc_gi_Tetrahedron_isInnerTetrahedron)); + cls->defineFunction("isOuterCell", _SE(js_cc_gi_Tetrahedron_isOuterCell)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Tetrahedron)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_Tetrahedron_proto = cls->getProto(); + __jsb_cc_gi_Tetrahedron_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_Delaunay_class = nullptr; +se::Object* __jsb_cc_gi_Delaunay_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_Delaunay) + +static bool js_new_cc_gi_Delaunay(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ccstd::vector< cc::gi::Vertex > *arg1 = 0 ; + ccstd::vector< cc::gi::Vertex > temp1 ; + cc::gi::Delaunay *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::gi::Delaunay *)new cc::gi::Delaunay(*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_Delaunay, __jsb_cc_gi_Delaunay_class, js_delete_cc_gi_Delaunay) + +static bool js_delete_cc_gi_Delaunay(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_Delaunay) + +static bool js_cc_gi_Delaunay_build(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::Delaunay *arg1 = (cc::gi::Delaunay *) NULL ; + ccstd::vector< cc::gi::Tetrahedron > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->build(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_gi_Delaunay_build) + +bool js_register_cc_gi_Delaunay(se::Object* obj) { + auto* cls = se::Class::create("Delaunay", obj, nullptr, _SE(js_new_cc_gi_Delaunay)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("build", _SE(js_cc_gi_Delaunay_build)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_Delaunay)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_Delaunay_proto = cls->getProto(); + __jsb_cc_gi_Delaunay_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_LightProbesData_class = nullptr; +se::Object* __jsb_cc_gi_LightProbesData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbesData) + +static bool js_new_cc_gi_LightProbesData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::LightProbesData *result; + result = (cc::gi::LightProbesData *)new cc::gi::LightProbesData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_LightProbesData, __jsb_cc_gi_LightProbesData_class, js_delete_cc_gi_LightProbesData) + +static bool js_cc_gi_LightProbesData_empty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbesData const *)arg1)->empty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_empty) + +static bool js_cc_gi_LightProbesData_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_reset) + +static bool js_cc_gi_LightProbesData_updateProbes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< Vec3 > *arg2 = 0 ; + ccstd::vector< Vec3 > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->updateProbes(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_updateProbes) + +static bool js_cc_gi_LightProbesData_updateTetrahedrons(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateTetrahedrons(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_updateTetrahedrons) + +static bool js_cc_gi_LightProbesData_hasCoefficients(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbesData const *)arg1)->hasCoefficients(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_hasCoefficients) + +static bool js_cc_gi_LightProbesData_getInterpolationSHCoefficients(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + int32_t arg2 ; + Vec4 *arg3 = 0 ; + ccstd::vector< Vec3 > *arg4 = 0 ; + Vec4 temp3 ; + ccstd::vector< Vec3 > temp4 ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (bool)((cc::gi::LightProbesData const *)arg1)->getInterpolationSHCoefficients(arg2,(Vec4 const &)*arg3,*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_getInterpolationSHCoefficients) + +static bool js_cc_gi_LightProbesData_getInterpolationWeights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + Vec3 *arg2 = 0 ; + int32_t arg3 ; + Vec4 *arg4 = 0 ; + Vec3 temp2 ; + Vec4 temp4 ; + int32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = ((cc::gi::LightProbesData const *)arg1)->getInterpolationWeights((Vec3 const &)*arg2,arg3,*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbesData_getInterpolationWeights) + +static bool js_cc_gi_LightProbesData__probes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_probes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData__probes_set) + +static bool js_cc_gi_LightProbesData__probes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_probes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_probes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData__probes_get) + +static bool js_cc_gi_LightProbesData__tetrahedrons_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_tetrahedrons, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData__tetrahedrons_set) + +static bool js_cc_gi_LightProbesData__tetrahedrons_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_tetrahedrons, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_tetrahedrons, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData__tetrahedrons_get) + +static bool js_cc_gi_LightProbesData_probes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Vertex > *arg2 = 0 ; + ccstd::vector< cc::gi::Vertex > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_gi_LightProbesData_probes_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData_probes_set) + +static bool js_cc_gi_LightProbesData_probes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Vertex > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gi::Vertex > *) &cc_gi_LightProbesData_probes_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData_probes_get) + +static bool js_cc_gi_LightProbesData_tetrahedrons_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Tetrahedron > *arg2 = 0 ; + ccstd::vector< cc::gi::Tetrahedron > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_gi_LightProbesData_tetrahedrons_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbesData_tetrahedrons_set) + +static bool js_cc_gi_LightProbesData_tetrahedrons_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbesData *arg1 = (cc::gi::LightProbesData *) NULL ; + ccstd::vector< cc::gi::Tetrahedron > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gi::Tetrahedron > *) &cc_gi_LightProbesData_tetrahedrons_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbesData_tetrahedrons_get) + +static bool js_delete_cc_gi_LightProbesData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbesData) + +bool js_register_cc_gi_LightProbesData(se::Object* obj) { + auto* cls = se::Class::create("LightProbesData", obj, nullptr, _SE(js_new_cc_gi_LightProbesData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_probes", _SE(js_cc_gi_LightProbesData__probes_get), _SE(js_cc_gi_LightProbesData__probes_set)); + cls->defineProperty("_tetrahedrons", _SE(js_cc_gi_LightProbesData__tetrahedrons_get), _SE(js_cc_gi_LightProbesData__tetrahedrons_set)); + cls->defineProperty("probes", _SE(js_cc_gi_LightProbesData_probes_get), _SE(js_cc_gi_LightProbesData_probes_set)); + cls->defineProperty("tetrahedrons", _SE(js_cc_gi_LightProbesData_tetrahedrons_get), _SE(js_cc_gi_LightProbesData_tetrahedrons_set)); + + cls->defineFunction("empty", _SE(js_cc_gi_LightProbesData_empty)); + cls->defineFunction("reset", _SE(js_cc_gi_LightProbesData_reset)); + cls->defineFunction("updateProbes", _SE(js_cc_gi_LightProbesData_updateProbes)); + cls->defineFunction("updateTetrahedrons", _SE(js_cc_gi_LightProbesData_updateTetrahedrons)); + cls->defineFunction("hasCoefficients", _SE(js_cc_gi_LightProbesData_hasCoefficients)); + cls->defineFunction("getInterpolationSHCoefficients", _SE(js_cc_gi_LightProbesData_getInterpolationSHCoefficients)); + cls->defineFunction("getInterpolationWeights", _SE(js_cc_gi_LightProbesData_getInterpolationWeights)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbesData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_LightProbesData_proto = cls->getProto(); + __jsb_cc_gi_LightProbesData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_LightProbes_class = nullptr; +se::Object* __jsb_cc_gi_LightProbes_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbes) + +static bool js_new_cc_gi_LightProbes(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::LightProbes *result; + result = (cc::gi::LightProbes *)new cc::gi::LightProbes(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_LightProbes, __jsb_cc_gi_LightProbes_class, js_delete_cc_gi_LightProbes) + +static bool js_delete_cc_gi_LightProbes(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbes) + +static bool js_cc_gi_LightProbes_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + cc::gi::LightProbeInfo *arg2 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbes_initialize) + +static bool js_cc_gi_LightProbes_empty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbes const *)arg1)->empty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbes_empty) + +static bool js_cc_gi_LightProbes__giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__giScale_set) + +static bool js_cc_gi_LightProbes__giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__giScale_get) + +static bool js_cc_gi_LightProbes__lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lightProbeSphereVolume, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbes__lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lightProbeSphereVolume, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbes__giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giSamples, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__giSamples_set) + +static bool js_cc_gi_LightProbes__giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giSamples, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__giSamples_get) + +static bool js_cc_gi_LightProbes__bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_bounces, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__bounces_set) + +static bool js_cc_gi_LightProbes__bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_bounces, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__bounces_get) + +static bool js_cc_gi_LightProbes__reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reduceRinging, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__reduceRinging_set) + +static bool js_cc_gi_LightProbes__reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reduceRinging, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__reduceRinging_get) + +static bool js_cc_gi_LightProbes__showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showProbe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__showProbe_set) + +static bool js_cc_gi_LightProbes__showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showProbe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__showProbe_get) + +static bool js_cc_gi_LightProbes__showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showWireframe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__showWireframe_set) + +static bool js_cc_gi_LightProbes__showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showWireframe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__showWireframe_get) + +static bool js_cc_gi_LightProbes__showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showConvex); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__showConvex_set) + +static bool js_cc_gi_LightProbes__showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showConvex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__showConvex_get) + +static bool js_cc_gi_LightProbes__data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes__data_set) + +static bool js_cc_gi_LightProbes__data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_data, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_data, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes__data_get) + +static bool js_cc_gi_LightProbes_giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_giScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_giScale_set) + +static bool js_cc_gi_LightProbes_giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbes_giScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_giScale_get) + +static bool js_cc_gi_LightProbes_giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbes_giSamples_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_giSamples_set) + +static bool js_cc_gi_LightProbes_giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbes_giSamples_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_giSamples_get) + +static bool js_cc_gi_LightProbes_bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbes_bounces_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_bounces_set) + +static bool js_cc_gi_LightProbes_bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbes_bounces_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_bounces_get) + +static bool js_cc_gi_LightProbes_reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_reduceRinging_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_reduceRinging_set) + +static bool js_cc_gi_LightProbes_reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbes_reduceRinging_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_reduceRinging_get) + +static bool js_cc_gi_LightProbes_showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_showProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_showProbe_set) + +static bool js_cc_gi_LightProbes_showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbes_showProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_showProbe_get) + +static bool js_cc_gi_LightProbes_showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_showWireframe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_showWireframe_set) + +static bool js_cc_gi_LightProbes_showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbes_showWireframe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_showWireframe_get) + +static bool js_cc_gi_LightProbes_lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_lightProbeSphereVolume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbes_lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbes_lightProbeSphereVolume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbes_showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_showConvex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_showConvex_set) + +static bool js_cc_gi_LightProbes_showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbes_showConvex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_showConvex_get) + +static bool js_cc_gi_LightProbes_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + cc::gi::LightProbesData *arg2 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbes_data_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbes_data_set) + +static bool js_cc_gi_LightProbes_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbes *arg1 = (cc::gi::LightProbes *) NULL ; + cc::gi::LightProbesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbesData *)cc_gi_LightProbes_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbes_data_get) + +bool js_register_cc_gi_LightProbes(se::Object* obj) { + auto* cls = se::Class::create("LightProbes", obj, nullptr, _SE(js_new_cc_gi_LightProbes)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_giScale", _SE(js_cc_gi_LightProbes__giScale_get), _SE(js_cc_gi_LightProbes__giScale_set)); + cls->defineProperty("_lightProbeSphereVolume", _SE(js_cc_gi_LightProbes__lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbes__lightProbeSphereVolume_set)); + cls->defineProperty("_giSamples", _SE(js_cc_gi_LightProbes__giSamples_get), _SE(js_cc_gi_LightProbes__giSamples_set)); + cls->defineProperty("_bounces", _SE(js_cc_gi_LightProbes__bounces_get), _SE(js_cc_gi_LightProbes__bounces_set)); + cls->defineProperty("_reduceRinging", _SE(js_cc_gi_LightProbes__reduceRinging_get), _SE(js_cc_gi_LightProbes__reduceRinging_set)); + cls->defineProperty("_showProbe", _SE(js_cc_gi_LightProbes__showProbe_get), _SE(js_cc_gi_LightProbes__showProbe_set)); + cls->defineProperty("_showWireframe", _SE(js_cc_gi_LightProbes__showWireframe_get), _SE(js_cc_gi_LightProbes__showWireframe_set)); + cls->defineProperty("_showConvex", _SE(js_cc_gi_LightProbes__showConvex_get), _SE(js_cc_gi_LightProbes__showConvex_set)); + cls->defineProperty("_data", _SE(js_cc_gi_LightProbes__data_get), _SE(js_cc_gi_LightProbes__data_set)); + cls->defineProperty("giScale", _SE(js_cc_gi_LightProbes_giScale_get), _SE(js_cc_gi_LightProbes_giScale_set)); + cls->defineProperty("giSamples", _SE(js_cc_gi_LightProbes_giSamples_get), _SE(js_cc_gi_LightProbes_giSamples_set)); + cls->defineProperty("bounces", _SE(js_cc_gi_LightProbes_bounces_get), _SE(js_cc_gi_LightProbes_bounces_set)); + cls->defineProperty("reduceRinging", _SE(js_cc_gi_LightProbes_reduceRinging_get), _SE(js_cc_gi_LightProbes_reduceRinging_set)); + cls->defineProperty("showProbe", _SE(js_cc_gi_LightProbes_showProbe_get), _SE(js_cc_gi_LightProbes_showProbe_set)); + cls->defineProperty("showWireframe", _SE(js_cc_gi_LightProbes_showWireframe_get), _SE(js_cc_gi_LightProbes_showWireframe_set)); + cls->defineProperty("lightProbeSphereVolume", _SE(js_cc_gi_LightProbes_lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbes_lightProbeSphereVolume_set)); + cls->defineProperty("showConvex", _SE(js_cc_gi_LightProbes_showConvex_get), _SE(js_cc_gi_LightProbes_showConvex_set)); + cls->defineProperty("data", _SE(js_cc_gi_LightProbes_data_get), _SE(js_cc_gi_LightProbes_data_set)); + + cls->defineFunction("initialize", _SE(js_cc_gi_LightProbes_initialize)); + cls->defineFunction("empty", _SE(js_cc_gi_LightProbes_empty)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbes)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_LightProbes_proto = cls->getProto(); + __jsb_cc_gi_LightProbes_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_gi_LightProbeInfo_class = nullptr; +se::Object* __jsb_cc_gi_LightProbeInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_gi_LightProbeInfo) + +static bool js_new_cc_gi_LightProbeInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::gi::LightProbeInfo *result; + result = (cc::gi::LightProbeInfo *)new cc::gi::LightProbeInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_gi_LightProbeInfo, __jsb_cc_gi_LightProbeInfo_class, js_delete_cc_gi_LightProbeInfo) + +static bool js_delete_cc_gi_LightProbeInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_gi_LightProbeInfo) + +static bool js_cc_gi_LightProbeInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Scene *arg2 = (cc::Scene *) NULL ; + cc::gi::LightProbes *arg3 = (cc::gi::LightProbes *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_activate) + +static bool js_cc_gi_LightProbeInfo_onProbeBakeFinished(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onProbeBakeFinished(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_onProbeBakeFinished) + +static bool js_cc_gi_LightProbeInfo_onProbeBakeCleared(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onProbeBakeCleared(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_onProbeBakeCleared) + +static bool js_cc_gi_LightProbeInfo_clearSHCoefficients(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearSHCoefficients(); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_clearSHCoefficients) + +static bool js_cc_gi_LightProbeInfo_isUniqueNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)((cc::gi::LightProbeInfo const *)arg1)->isUniqueNode(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_isUniqueNode) + +static bool js_cc_gi_LightProbeInfo_addNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->addNode(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_addNode) + +static bool js_cc_gi_LightProbeInfo_removeNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->removeNode(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_removeNode) + +static bool js_cc_gi_LightProbeInfo_syncData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + ccstd::vector< Vec3 > *arg3 = 0 ; + ccstd::vector< Vec3 > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->syncData(arg2,(ccstd::vector< Vec3 > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_syncData) + +static bool js_cc_gi_LightProbeInfo_update__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} + +static bool js_cc_gi_LightProbeInfo_update__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} + +static bool js_cc_gi_LightProbeInfo_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_gi_LightProbeInfo_update__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_gi_LightProbeInfo_update__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_gi_LightProbeInfo_update) + +static bool js_cc_gi_LightProbeInfo__giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giScale, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__giScale_set) + +static bool js_cc_gi_LightProbeInfo__giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giScale, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__giScale_get) + +static bool js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_lightProbeSphereVolume, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_lightProbeSphereVolume, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbeInfo__giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_giSamples, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__giSamples_set) + +static bool js_cc_gi_LightProbeInfo__giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_giSamples, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__giSamples_get) + +static bool js_cc_gi_LightProbeInfo__bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_bounces, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__bounces_set) + +static bool js_cc_gi_LightProbeInfo__bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_bounces, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__bounces_get) + +static bool js_cc_gi_LightProbeInfo__reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reduceRinging, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__reduceRinging_set) + +static bool js_cc_gi_LightProbeInfo__reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reduceRinging, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__reduceRinging_get) + +static bool js_cc_gi_LightProbeInfo__showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showProbe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showProbe_set) + +static bool js_cc_gi_LightProbeInfo__showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showProbe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showProbe_get) + +static bool js_cc_gi_LightProbeInfo__showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showWireframe); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showWireframe_set) + +static bool js_cc_gi_LightProbeInfo__showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showWireframe, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showWireframe_get) + +static bool js_cc_gi_LightProbeInfo__showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_showConvex); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__showConvex_set) + +static bool js_cc_gi_LightProbeInfo__showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_showConvex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__showConvex_get) + +static bool js_cc_gi_LightProbeInfo__data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo__data_set) + +static bool js_cc_gi_LightProbeInfo__data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_data, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_data, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo__data_get) + +static bool js_cc_gi_LightProbeInfo_giScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_giScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_giScale_set) + +static bool js_cc_gi_LightProbeInfo_giScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbeInfo_giScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_giScale_get) + +static bool js_cc_gi_LightProbeInfo_giSamples_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbeInfo_giSamples_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_giSamples_set) + +static bool js_cc_gi_LightProbeInfo_giSamples_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbeInfo_giSamples_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_giSamples_get) + +static bool js_cc_gi_LightProbeInfo_bounces_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_gi_LightProbeInfo_bounces_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_bounces_set) + +static bool js_cc_gi_LightProbeInfo_bounces_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_gi_LightProbeInfo_bounces_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_bounces_get) + +static bool js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_lightProbeSphereVolume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set) + +static bool js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbeInfo_lightProbeSphereVolume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get) + +static bool js_cc_gi_LightProbeInfo_reduceRinging_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_reduceRinging_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_reduceRinging_set) + +static bool js_cc_gi_LightProbeInfo_reduceRinging_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_gi_LightProbeInfo_reduceRinging_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_reduceRinging_get) + +static bool js_cc_gi_LightProbeInfo_showProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_showProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showProbe_set) + +static bool js_cc_gi_LightProbeInfo_showProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbeInfo_showProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showProbe_get) + +static bool js_cc_gi_LightProbeInfo_showWireframe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_showWireframe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showWireframe_set) + +static bool js_cc_gi_LightProbeInfo_showWireframe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbeInfo_showWireframe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showWireframe_get) + +static bool js_cc_gi_LightProbeInfo_showConvex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_showConvex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_showConvex_set) + +static bool js_cc_gi_LightProbeInfo_showConvex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_gi_LightProbeInfo_showConvex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_showConvex_get) + +static bool js_cc_gi_LightProbeInfo_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::gi::LightProbesData *arg2 = (cc::gi::LightProbesData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_gi_LightProbeInfo_data_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_gi_LightProbeInfo_data_set) + +static bool js_cc_gi_LightProbeInfo_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::gi::LightProbeInfo *arg1 = (cc::gi::LightProbeInfo *) NULL ; + cc::gi::LightProbesData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbesData *)cc_gi_LightProbeInfo_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_gi_LightProbeInfo_data_get) + +bool js_register_cc_gi_LightProbeInfo(se::Object* obj) { + auto* cls = se::Class::create("LightProbeInfo", obj, nullptr, _SE(js_new_cc_gi_LightProbeInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_giScale", _SE(js_cc_gi_LightProbeInfo__giScale_get), _SE(js_cc_gi_LightProbeInfo__giScale_set)); + cls->defineProperty("_lightProbeSphereVolume", _SE(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbeInfo__lightProbeSphereVolume_set)); + cls->defineProperty("_giSamples", _SE(js_cc_gi_LightProbeInfo__giSamples_get), _SE(js_cc_gi_LightProbeInfo__giSamples_set)); + cls->defineProperty("_bounces", _SE(js_cc_gi_LightProbeInfo__bounces_get), _SE(js_cc_gi_LightProbeInfo__bounces_set)); + cls->defineProperty("_reduceRinging", _SE(js_cc_gi_LightProbeInfo__reduceRinging_get), _SE(js_cc_gi_LightProbeInfo__reduceRinging_set)); + cls->defineProperty("_showProbe", _SE(js_cc_gi_LightProbeInfo__showProbe_get), _SE(js_cc_gi_LightProbeInfo__showProbe_set)); + cls->defineProperty("_showWireframe", _SE(js_cc_gi_LightProbeInfo__showWireframe_get), _SE(js_cc_gi_LightProbeInfo__showWireframe_set)); + cls->defineProperty("_showConvex", _SE(js_cc_gi_LightProbeInfo__showConvex_get), _SE(js_cc_gi_LightProbeInfo__showConvex_set)); + cls->defineProperty("_data", _SE(js_cc_gi_LightProbeInfo__data_get), _SE(js_cc_gi_LightProbeInfo__data_set)); + cls->defineProperty("giScale", _SE(js_cc_gi_LightProbeInfo_giScale_get), _SE(js_cc_gi_LightProbeInfo_giScale_set)); + cls->defineProperty("giSamples", _SE(js_cc_gi_LightProbeInfo_giSamples_get), _SE(js_cc_gi_LightProbeInfo_giSamples_set)); + cls->defineProperty("bounces", _SE(js_cc_gi_LightProbeInfo_bounces_get), _SE(js_cc_gi_LightProbeInfo_bounces_set)); + cls->defineProperty("lightProbeSphereVolume", _SE(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_get), _SE(js_cc_gi_LightProbeInfo_lightProbeSphereVolume_set)); + cls->defineProperty("reduceRinging", _SE(js_cc_gi_LightProbeInfo_reduceRinging_get), _SE(js_cc_gi_LightProbeInfo_reduceRinging_set)); + cls->defineProperty("showProbe", _SE(js_cc_gi_LightProbeInfo_showProbe_get), _SE(js_cc_gi_LightProbeInfo_showProbe_set)); + cls->defineProperty("showWireframe", _SE(js_cc_gi_LightProbeInfo_showWireframe_get), _SE(js_cc_gi_LightProbeInfo_showWireframe_set)); + cls->defineProperty("showConvex", _SE(js_cc_gi_LightProbeInfo_showConvex_get), _SE(js_cc_gi_LightProbeInfo_showConvex_set)); + cls->defineProperty("data", _SE(js_cc_gi_LightProbeInfo_data_get), _SE(js_cc_gi_LightProbeInfo_data_set)); + + cls->defineFunction("activate", _SE(js_cc_gi_LightProbeInfo_activate)); + cls->defineFunction("onProbeBakeFinished", _SE(js_cc_gi_LightProbeInfo_onProbeBakeFinished)); + cls->defineFunction("onProbeBakeCleared", _SE(js_cc_gi_LightProbeInfo_onProbeBakeCleared)); + cls->defineFunction("clearSHCoefficients", _SE(js_cc_gi_LightProbeInfo_clearSHCoefficients)); + cls->defineFunction("isUniqueNode", _SE(js_cc_gi_LightProbeInfo_isUniqueNode)); + cls->defineFunction("addNode", _SE(js_cc_gi_LightProbeInfo_addNode)); + cls->defineFunction("removeNode", _SE(js_cc_gi_LightProbeInfo_removeNode)); + cls->defineFunction("syncData", _SE(js_cc_gi_LightProbeInfo_syncData)); + cls->defineFunction("update", _SE(js_cc_gi_LightProbeInfo_update)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_gi_LightProbeInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_gi_LightProbeInfo_proto = cls->getProto(); + __jsb_cc_gi_LightProbeInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_gi(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_gi_Vertex(ns); + js_register_cc_gi_CircumSphere(ns); + js_register_cc_gi_Tetrahedron(ns); + js_register_cc_gi_Delaunay(ns); + js_register_cc_gi_LightProbesData(ns); + js_register_cc_gi_LightProbes(ns); + js_register_cc_gi_LightProbeInfo(ns); + + /* Register global variables & global functions */ + + + + return true; +} + + +#if defined(__clang__) +#pragma clang diagnostic pop +#elif defined(__GNUC__) || defined(__GNUG__) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_gi_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gi_auto.h new file mode 100644 index 0000000000..79d476f6ab --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_gi_auto.h @@ -0,0 +1,92 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "gi/light-probe/Delaunay.h" +#include "gi/light-probe/LightProbe.h" + + + +bool register_all_gi(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::Vertex); +extern se::Object *__jsb_cc_gi_Vertex_proto; // NOLINT +extern se::Class * __jsb_cc_gi_Vertex_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Vertex * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::CircumSphere); +extern se::Object *__jsb_cc_gi_CircumSphere_proto; // NOLINT +extern se::Class * __jsb_cc_gi_CircumSphere_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::CircumSphere * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::Tetrahedron); +extern se::Object *__jsb_cc_gi_Tetrahedron_proto; // NOLINT +extern se::Class * __jsb_cc_gi_Tetrahedron_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::gi::Tetrahedron * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::Delaunay); +extern se::Object *__jsb_cc_gi_Delaunay_proto; // NOLINT +extern se::Class * __jsb_cc_gi_Delaunay_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::LightProbesData); +extern se::Object *__jsb_cc_gi_LightProbesData_proto; // NOLINT +extern se::Class * __jsb_cc_gi_LightProbesData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::LightProbes); +extern se::Object *__jsb_cc_gi_LightProbes_proto; // NOLINT +extern se::Class * __jsb_cc_gi_LightProbes_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::gi::LightProbeInfo); +extern se::Object *__jsb_cc_gi_LightProbeInfo_proto; // NOLINT +extern se::Class * __jsb_cc_gi_LightProbeInfo_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_network_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_network_auto.cpp new file mode 100644 index 0000000000..18259548b7 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_network_auto.cpp @@ -0,0 +1,811 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_network_auto.h" + + +#define cc_network_Downloader_onProgress_set(self_, val_) self_->setOnProgress(val_) + + + +se::Class* __jsb_cc_network_DownloadTask_class = nullptr; +se::Object* __jsb_cc_network_DownloadTask_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_network_DownloadTask) + +static bool js_cc_network_DownloadTask_identifier_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->identifier, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_identifier_set) + +static bool js_cc_network_DownloadTask_identifier_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->identifier, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->identifier, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_identifier_get) + +static bool js_cc_network_DownloadTask_requestURL_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->requestURL, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_requestURL_set) + +static bool js_cc_network_DownloadTask_requestURL_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->requestURL, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->requestURL, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_requestURL_get) + +static bool js_cc_network_DownloadTask_storagePath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storagePath, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_storagePath_set) + +static bool js_cc_network_DownloadTask_storagePath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storagePath, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storagePath, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_storagePath_get) + +static bool js_cc_network_DownloadTask_header_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->header, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloadTask_header_set) + +static bool js_cc_network_DownloadTask_header_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloadTask *arg1 = (cc::network::DownloadTask *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->header, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->header, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloadTask_header_get) + +static bool js_new_cc_network_DownloadTask(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::network::DownloadTask *result; + result = (cc::network::DownloadTask *)new cc::network::DownloadTask(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_network_DownloadTask, __jsb_cc_network_DownloadTask_class, js_delete_cc_network_DownloadTask) + +static bool js_delete_cc_network_DownloadTask(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_network_DownloadTask) + +bool js_register_cc_network_DownloadTask(se::Object* obj) { + auto* cls = se::Class::create("DownloadTask", obj, nullptr, _SE(js_new_cc_network_DownloadTask)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("identifier", _SE(js_cc_network_DownloadTask_identifier_get), _SE(js_cc_network_DownloadTask_identifier_set)); + cls->defineProperty("requestURL", _SE(js_cc_network_DownloadTask_requestURL_get), _SE(js_cc_network_DownloadTask_requestURL_set)); + cls->defineProperty("storagePath", _SE(js_cc_network_DownloadTask_storagePath_get), _SE(js_cc_network_DownloadTask_storagePath_set)); + cls->defineProperty("header", _SE(js_cc_network_DownloadTask_header_get), _SE(js_cc_network_DownloadTask_header_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_network_DownloadTask)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_network_DownloadTask_proto = cls->getProto(); + __jsb_cc_network_DownloadTask_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_network_DownloaderHints_class = nullptr; +se::Object* __jsb_cc_network_DownloaderHints_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_network_DownloaderHints) + +static bool js_cc_network_DownloaderHints_countOfMaxProcessingTasks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->countOfMaxProcessingTasks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_set) + +static bool js_cc_network_DownloaderHints_countOfMaxProcessingTasks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->countOfMaxProcessingTasks, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_get) + +static bool js_cc_network_DownloaderHints_timeoutInSeconds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->timeoutInSeconds, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloaderHints_timeoutInSeconds_set) + +static bool js_cc_network_DownloaderHints_timeoutInSeconds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->timeoutInSeconds, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloaderHints_timeoutInSeconds_get) + +static bool js_cc_network_DownloaderHints_tempFileNameSuffix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tempFileNameSuffix, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_DownloaderHints_tempFileNameSuffix_set) + +static bool js_cc_network_DownloaderHints_tempFileNameSuffix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = (cc::network::DownloaderHints *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tempFileNameSuffix, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->tempFileNameSuffix, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_DownloaderHints_tempFileNameSuffix_get) + +static bool js_new_cc_network_DownloaderHints(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::network::DownloaderHints *result; + result = (cc::network::DownloaderHints *)new cc::network::DownloaderHints(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_network_DownloaderHints, __jsb_cc_network_DownloaderHints_class, js_delete_cc_network_DownloaderHints) + +static bool js_delete_cc_network_DownloaderHints(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_network_DownloaderHints) + +template<> +bool sevalue_to_native(const se::Value &from, cc::network::DownloaderHints * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("countOfMaxProcessingTasks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->countOfMaxProcessingTasks), ctx); + } + + + json->getProperty("timeoutInSeconds", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->timeoutInSeconds), ctx); + } + + + json->getProperty("tempFileNameSuffix", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tempFileNameSuffix), ctx); + } + + + return ok; +} + + +bool js_register_cc_network_DownloaderHints(se::Object* obj) { + auto* cls = se::Class::create("DownloaderHints", obj, nullptr, _SE(js_new_cc_network_DownloaderHints)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("countOfMaxProcessingTasks", _SE(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_get), _SE(js_cc_network_DownloaderHints_countOfMaxProcessingTasks_set)); + cls->defineProperty("timeoutInSeconds", _SE(js_cc_network_DownloaderHints_timeoutInSeconds_get), _SE(js_cc_network_DownloaderHints_timeoutInSeconds_set)); + cls->defineProperty("tempFileNameSuffix", _SE(js_cc_network_DownloaderHints_tempFileNameSuffix_get), _SE(js_cc_network_DownloaderHints_tempFileNameSuffix_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_network_DownloaderHints)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_network_DownloaderHints_proto = cls->getProto(); + __jsb_cc_network_DownloaderHints_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_network_Downloader_class = nullptr; +se::Object* __jsb_cc_network_Downloader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_network_Downloader) + +static bool js_new_cc_network_Downloader__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::network::Downloader *result; + result = (cc::network::Downloader *)new cc::network::Downloader(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_network_Downloader__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::network::DownloaderHints *arg1 = 0 ; + cc::network::DownloaderHints temp1 ; + cc::network::Downloader *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::network::Downloader *)new cc::network::Downloader((cc::network::DownloaderHints const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_network_Downloader(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_network_Downloader__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_network_Downloader__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Downloader"); + return false; +} +SE_BIND_CTOR(js_new_cc_network_Downloader, __jsb_cc_network_Downloader_class, js_delete_cc_network_Downloader) + +static bool js_delete_cc_network_Downloader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_network_Downloader) + +static bool js_cc_network_Downloader_onDataTaskSuccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onDataTaskSuccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onDataTaskSuccess_set) + +static bool js_cc_network_Downloader_onDataTaskSuccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onDataTaskSuccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onDataTaskSuccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onDataTaskSuccess_get) + +static bool js_cc_network_Downloader_onFileTaskSuccess_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onFileTaskSuccess, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onFileTaskSuccess_set) + +static bool js_cc_network_Downloader_onFileTaskSuccess_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onFileTaskSuccess, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onFileTaskSuccess, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onFileTaskSuccess_get) + +static bool js_cc_network_Downloader_onTaskProgress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onTaskProgress, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onTaskProgress_set) + +static bool js_cc_network_Downloader_onTaskProgress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onTaskProgress, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onTaskProgress, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onTaskProgress_get) + +static bool js_cc_network_Downloader_onTaskError_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->onTaskError, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onTaskError_set) + +static bool js_cc_network_Downloader_onTaskError_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->onTaskError, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->onTaskError, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_network_Downloader_onTaskError_get) + +static bool js_cc_network_Downloader_setOnTaskProgress(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > *arg2 = 0 ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setOnTaskProgress((std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_network_Downloader_setOnTaskProgress) + +static bool js_cc_network_Downloader_abort(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + std::shared_ptr< cc::network::DownloadTask const > *arg2 = 0 ; + std::shared_ptr< cc::network::DownloadTask const > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->abort((std::shared_ptr< cc::network::DownloadTask const > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_network_Downloader_abort) + +static bool js_cc_network_Downloader_onProgress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::network::Downloader *arg1 = (cc::network::Downloader *) NULL ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > *arg2 = 0 ; + std::function< void (cc::network::DownloadTask const &,uint32_t,uint32_t,uint32_t) > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_network_Downloader_onProgress_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_network_Downloader_onProgress_set) + +bool js_register_cc_network_Downloader(se::Object* obj) { + auto* cls = se::Class::create("Downloader", obj, nullptr, _SE(js_new_cc_network_Downloader)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("onDataTaskSuccess", _SE(js_cc_network_Downloader_onDataTaskSuccess_get), _SE(js_cc_network_Downloader_onDataTaskSuccess_set)); + cls->defineProperty("onFileTaskSuccess", _SE(js_cc_network_Downloader_onFileTaskSuccess_get), _SE(js_cc_network_Downloader_onFileTaskSuccess_set)); + cls->defineProperty("onTaskProgress", _SE(js_cc_network_Downloader_onTaskProgress_get), _SE(js_cc_network_Downloader_onTaskProgress_set)); + cls->defineProperty("onTaskError", _SE(js_cc_network_Downloader_onTaskError_get), _SE(js_cc_network_Downloader_onTaskError_set)); + cls->defineProperty("onProgress", nullptr, _SE(js_cc_network_Downloader_onProgress_set)); + + cls->defineFunction("setOnTaskProgress", _SE(js_cc_network_Downloader_setOnTaskProgress)); + cls->defineFunction("abort", _SE(js_cc_network_Downloader_abort)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_network_Downloader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_network_Downloader_proto = cls->getProto(); + __jsb_cc_network_Downloader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_network(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_network_DownloadTask(ns); + js_register_cc_network_DownloaderHints(ns); + js_register_cc_network_Downloader(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_network_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_network_auto.h new file mode 100644 index 0000000000..37cc477775 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_network_auto.h @@ -0,0 +1,63 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "network/Downloader.h" + + + +bool register_all_network(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::network::DownloadTask); +extern se::Object *__jsb_cc_network_DownloadTask_proto; // NOLINT +extern se::Class * __jsb_cc_network_DownloadTask_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::network::DownloaderHints); +extern se::Object *__jsb_cc_network_DownloaderHints_proto; // NOLINT +extern se::Class * __jsb_cc_network_DownloaderHints_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::network::DownloaderHints * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::network::Downloader); +extern se::Object *__jsb_cc_network_Downloader_proto; // NOLINT +extern se::Class * __jsb_cc_network_Downloader_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_physics_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_physics_auto.cpp new file mode 100644 index 0000000000..6f66fa96dc --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_physics_auto.cpp @@ -0,0 +1,9765 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_physics_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_geometry_auto.h" + + + +se::Class* __jsb_cc_physics_World_class = nullptr; +se::Object* __jsb_cc_physics_World_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_World) + +static bool js_new_cc_physics_World(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::World *result; + result = (cc::physics::World *)new cc::physics::World(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_World, __jsb_cc_physics_World_class, js_delete_cc_physics_World) + +static bool js_delete_cc_physics_World(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_World) + +static bool js_cc_physics_World_setGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setGravity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setGravity) + +static bool js_cc_physics_World_setAllowSleep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAllowSleep(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setAllowSleep) + +static bool js_cc_physics_World_step(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->step(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_step) + +static bool js_cc_physics_World_emitEvents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->emitEvents(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_emitEvents) + +static bool js_cc_physics_World_syncSceneToPhysics(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncSceneToPhysics(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_syncSceneToPhysics) + +static bool js_cc_physics_World_syncSceneWithCheck(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncSceneWithCheck(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_syncSceneWithCheck) + +static bool js_cc_physics_World_setDebugDrawFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::EPhysicsDrawFlags arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDebugDrawFlags(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setDebugDrawFlags) + +static bool js_cc_physics_World_getDebugDrawFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::EPhysicsDrawFlags result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::physics::EPhysicsDrawFlags)(arg1)->getDebugDrawFlags(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_getDebugDrawFlags) + +static bool js_cc_physics_World_setDebugDrawConstraintSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugDrawConstraintSize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setDebugDrawConstraintSize) + +static bool js_cc_physics_World_getDebugDrawConstraintSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getDebugDrawConstraintSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_getDebugDrawConstraintSize) + +static bool js_cc_physics_World_setCollisionMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCollisionMatrix(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setCollisionMatrix) + +static bool js_cc_physics_World_getTriggerEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::TriggerEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::TriggerEventPair > > *) &(arg1)->getTriggerEventPairs(); + + 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_physics_World_getTriggerEventPairs) + +static bool js_cc_physics_World_getContactEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::ContactEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::ContactEventPair > > *) &(arg1)->getContactEventPairs(); + + 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_physics_World_getContactEventPairs) + +static bool js_cc_physics_World_getCCTShapeEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::CCTShapeEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::CCTShapeEventPair > > *) &(arg1)->getCCTShapeEventPairs(); + + 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_physics_World_getCCTShapeEventPairs) + +static bool js_cc_physics_World_getCCTTriggerEventPairs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< std::shared_ptr< cc::physics::CCTTriggerEventPair > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< std::shared_ptr< cc::physics::CCTTriggerEventPair > > *) &(arg1)->getCCTTriggerEventPairs(); + + 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_physics_World_getCCTTriggerEventPairs) + +static bool js_cc_physics_World_raycast(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + cc::physics::RaycastOptions 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(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)(arg1)->raycast(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_raycast) + +static bool js_cc_physics_World_raycastClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + cc::physics::RaycastOptions 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(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)(arg1)->raycastClosest(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_raycastClosest) + +static bool js_cc_physics_World_raycastResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< cc::physics::RaycastResult > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::physics::RaycastResult > *) &(arg1)->raycastResult(); + + 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_physics_World_raycastResult) + +static bool js_cc_physics_World_raycastClosestResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastResult *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(s); + if (nullptr == arg1) return true; + result = (cc::physics::RaycastResult *) &(arg1)->raycastClosestResult(); + + 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_physics_World_raycastClosestResult) + +static bool js_cc_physics_World_sweepBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepBox(*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepBox) + +static bool js_cc_physics_World_sweepBoxClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepBoxClosest(*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepBoxClosest) + +static bool js_cc_physics_World_sweepSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->sweepSphere(*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepSphere) + +static bool js_cc_physics_World_sweepSphereClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->sweepSphereClosest(*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepSphereClosest) + +static bool js_cc_physics_World_sweepCapsule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepCapsule(*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepCapsule) + +static bool js_cc_physics_World_sweepCapsuleClosest(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastOptions *arg2 = 0 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + cc::physics::RaycastOptions temp2 ; + bool result; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->sweepCapsuleClosest(*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_sweepCapsuleClosest) + +static bool js_cc_physics_World_sweepClosestResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::RaycastResult *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(s); + if (nullptr == arg1) return true; + result = (cc::physics::RaycastResult *) &(arg1)->sweepClosestResult(); + + 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_physics_World_sweepClosestResult) + +static bool js_cc_physics_World_sweepResult(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + ccstd::vector< cc::physics::RaycastResult > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::physics::RaycastResult > *) &(arg1)->sweepResult(); + + 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_physics_World_sweepResult) + +static bool js_cc_physics_World_createConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::ConvexDesc *arg2 = 0 ; + cc::physics::ConvexDesc 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(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 = (arg1)->createConvex(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createConvex) + +static bool js_cc_physics_World_createTrimesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::TrimeshDesc *arg2 = 0 ; + cc::physics::TrimeshDesc 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(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 = (arg1)->createTrimesh(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createTrimesh) + +static bool js_cc_physics_World_createHeightField(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + cc::physics::HeightFieldDesc *arg2 = 0 ; + cc::physics::HeightFieldDesc 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(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 = (arg1)->createHeightField(*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createHeightField) + +static bool js_cc_physics_World_createMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + bool result; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)(arg1)->createMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_createMaterial) + +static bool js_cc_physics_World_getFixedTimeStep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::physics::World const *)arg1)->getFixedTimeStep(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_getFixedTimeStep) + +static bool js_cc_physics_World_setFixedTimeStep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFixedTimeStep(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_setFixedTimeStep) + +static bool js_cc_physics_World_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::World *arg1 = (cc::physics::World *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_World_destroy) + +bool js_register_cc_physics_World(se::Object* obj) { + auto* cls = se::Class::create("World", obj, nullptr, _SE(js_new_cc_physics_World)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setGravity", _SE(js_cc_physics_World_setGravity)); + cls->defineFunction("setAllowSleep", _SE(js_cc_physics_World_setAllowSleep)); + cls->defineFunction("step", _SE(js_cc_physics_World_step)); + cls->defineFunction("emitEvents", _SE(js_cc_physics_World_emitEvents)); + cls->defineFunction("syncSceneToPhysics", _SE(js_cc_physics_World_syncSceneToPhysics)); + cls->defineFunction("syncSceneWithCheck", _SE(js_cc_physics_World_syncSceneWithCheck)); + cls->defineFunction("setDebugDrawFlags", _SE(js_cc_physics_World_setDebugDrawFlags)); + cls->defineFunction("getDebugDrawFlags", _SE(js_cc_physics_World_getDebugDrawFlags)); + cls->defineFunction("setDebugDrawConstraintSize", _SE(js_cc_physics_World_setDebugDrawConstraintSize)); + cls->defineFunction("getDebugDrawConstraintSize", _SE(js_cc_physics_World_getDebugDrawConstraintSize)); + cls->defineFunction("setCollisionMatrix", _SE(js_cc_physics_World_setCollisionMatrix)); + cls->defineFunction("getTriggerEventPairs", _SE(js_cc_physics_World_getTriggerEventPairs)); + cls->defineFunction("getContactEventPairs", _SE(js_cc_physics_World_getContactEventPairs)); + cls->defineFunction("getCCTShapeEventPairs", _SE(js_cc_physics_World_getCCTShapeEventPairs)); + cls->defineFunction("getCCTTriggerEventPairs", _SE(js_cc_physics_World_getCCTTriggerEventPairs)); + cls->defineFunction("raycast", _SE(js_cc_physics_World_raycast)); + cls->defineFunction("raycastClosest", _SE(js_cc_physics_World_raycastClosest)); + cls->defineFunction("raycastResult", _SE(js_cc_physics_World_raycastResult)); + cls->defineFunction("raycastClosestResult", _SE(js_cc_physics_World_raycastClosestResult)); + cls->defineFunction("sweepBox", _SE(js_cc_physics_World_sweepBox)); + cls->defineFunction("sweepBoxClosest", _SE(js_cc_physics_World_sweepBoxClosest)); + cls->defineFunction("sweepSphere", _SE(js_cc_physics_World_sweepSphere)); + cls->defineFunction("sweepSphereClosest", _SE(js_cc_physics_World_sweepSphereClosest)); + cls->defineFunction("sweepCapsule", _SE(js_cc_physics_World_sweepCapsule)); + cls->defineFunction("sweepCapsuleClosest", _SE(js_cc_physics_World_sweepCapsuleClosest)); + cls->defineFunction("sweepClosestResult", _SE(js_cc_physics_World_sweepClosestResult)); + cls->defineFunction("sweepResult", _SE(js_cc_physics_World_sweepResult)); + cls->defineFunction("createConvex", _SE(js_cc_physics_World_createConvex)); + cls->defineFunction("createTrimesh", _SE(js_cc_physics_World_createTrimesh)); + cls->defineFunction("createHeightField", _SE(js_cc_physics_World_createHeightField)); + cls->defineFunction("createMaterial", _SE(js_cc_physics_World_createMaterial)); + cls->defineFunction("getFixedTimeStep", _SE(js_cc_physics_World_getFixedTimeStep)); + cls->defineFunction("setFixedTimeStep", _SE(js_cc_physics_World_setFixedTimeStep)); + cls->defineFunction("destroy", _SE(js_cc_physics_World_destroy)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_World)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_World_proto = cls->getProto(); + __jsb_cc_physics_World_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_RigidBody_class = nullptr; +se::Object* __jsb_cc_physics_RigidBody_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_RigidBody) + +static bool js_new_cc_physics_RigidBody(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::RigidBody *result; + result = (cc::physics::RigidBody *)new cc::physics::RigidBody(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_RigidBody, __jsb_cc_physics_RigidBody_class, js_delete_cc_physics_RigidBody) + +static bool js_delete_cc_physics_RigidBody(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_RigidBody) + +static bool js_cc_physics_RigidBody_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + cc::physics::ERigidBodyType arg3 ; + uint32_t arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_initialize) + +static bool js_cc_physics_RigidBody_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_onEnable) + +static bool js_cc_physics_RigidBody_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_onDisable) + +static bool js_cc_physics_RigidBody_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_onDestroy) + +static bool js_cc_physics_RigidBody_isAwake(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isAwake(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_isAwake) + +static bool js_cc_physics_RigidBody_isSleepy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isSleepy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_isSleepy) + +static bool js_cc_physics_RigidBody_isSleeping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isSleeping(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_isSleeping) + +static bool js_cc_physics_RigidBody_setType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::physics::ERigidBodyType arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setType(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setType) + +static bool js_cc_physics_RigidBody_setMass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMass(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setMass) + +static bool js_cc_physics_RigidBody_setLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setLinearDamping) + +static bool js_cc_physics_RigidBody_setAngularDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAngularDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAngularDamping) + +static bool js_cc_physics_RigidBody_useGravity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useGravity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_useGravity) + +static bool js_cc_physics_RigidBody_useCCD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useCCD(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_useCCD) + +static bool js_cc_physics_RigidBody_setLinearFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearFactor(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setLinearFactor) + +static bool js_cc_physics_RigidBody_setAngularFactor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularFactor(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAngularFactor) + +static bool js_cc_physics_RigidBody_setAllowSleep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAllowSleep(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAllowSleep) + +static bool js_cc_physics_RigidBody_wakeUp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->wakeUp(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_wakeUp) + +static bool js_cc_physics_RigidBody_sleep(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->sleep(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_sleep) + +static bool js_cc_physics_RigidBody_clearState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearState(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_clearState) + +static bool js_cc_physics_RigidBody_clearForces(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearForces(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_clearForces) + +static bool js_cc_physics_RigidBody_clearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearVelocity(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_clearVelocity) + +static bool js_cc_physics_RigidBody_setSleepThreshold(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSleepThreshold(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setSleepThreshold) + +static bool js_cc_physics_RigidBody_getSleepThreshold(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getSleepThreshold(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getSleepThreshold) + +static bool js_cc_physics_RigidBody_getLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getLinearVelocity(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getLinearVelocity) + +static bool js_cc_physics_RigidBody_setLinearVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setLinearVelocity) + +static bool js_cc_physics_RigidBody_getAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getAngularVelocity(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getAngularVelocity) + +static bool js_cc_physics_RigidBody_setAngularVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setAngularVelocity) + +static bool js_cc_physics_RigidBody_applyForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyForce(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyForce) + +static bool js_cc_physics_RigidBody_applyLocalForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyLocalForce(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyLocalForce) + +static bool js_cc_physics_RigidBody_applyImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyImpulse(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyImpulse) + +static bool js_cc_physics_RigidBody_applyLocalImpulse(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->applyLocalImpulse(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyLocalImpulse) + +static bool js_cc_physics_RigidBody_applyTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->applyTorque(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyTorque) + +static bool js_cc_physics_RigidBody_applyLocalTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->applyLocalTorque(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_applyLocalTorque) + +static bool js_cc_physics_RigidBody_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getGroup) + +static bool js_cc_physics_RigidBody_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setGroup) + +static bool js_cc_physics_RigidBody_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getMask) + +static bool js_cc_physics_RigidBody_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_setMask) + +static bool js_cc_physics_RigidBody_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RigidBody *arg1 = (cc::physics::RigidBody *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::RigidBody const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RigidBody_getObjectID) + +bool js_register_cc_physics_RigidBody(se::Object* obj) { + auto* cls = se::Class::create("RigidBody", obj, nullptr, _SE(js_new_cc_physics_RigidBody)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_RigidBody_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_RigidBody_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_RigidBody_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_RigidBody_onDestroy)); + cls->defineFunction("isAwake", _SE(js_cc_physics_RigidBody_isAwake)); + cls->defineFunction("isSleepy", _SE(js_cc_physics_RigidBody_isSleepy)); + cls->defineFunction("isSleeping", _SE(js_cc_physics_RigidBody_isSleeping)); + cls->defineFunction("setType", _SE(js_cc_physics_RigidBody_setType)); + cls->defineFunction("setMass", _SE(js_cc_physics_RigidBody_setMass)); + cls->defineFunction("setLinearDamping", _SE(js_cc_physics_RigidBody_setLinearDamping)); + cls->defineFunction("setAngularDamping", _SE(js_cc_physics_RigidBody_setAngularDamping)); + cls->defineFunction("useGravity", _SE(js_cc_physics_RigidBody_useGravity)); + cls->defineFunction("useCCD", _SE(js_cc_physics_RigidBody_useCCD)); + cls->defineFunction("setLinearFactor", _SE(js_cc_physics_RigidBody_setLinearFactor)); + cls->defineFunction("setAngularFactor", _SE(js_cc_physics_RigidBody_setAngularFactor)); + cls->defineFunction("setAllowSleep", _SE(js_cc_physics_RigidBody_setAllowSleep)); + cls->defineFunction("wakeUp", _SE(js_cc_physics_RigidBody_wakeUp)); + cls->defineFunction("sleep", _SE(js_cc_physics_RigidBody_sleep)); + cls->defineFunction("clearState", _SE(js_cc_physics_RigidBody_clearState)); + cls->defineFunction("clearForces", _SE(js_cc_physics_RigidBody_clearForces)); + cls->defineFunction("clearVelocity", _SE(js_cc_physics_RigidBody_clearVelocity)); + cls->defineFunction("setSleepThreshold", _SE(js_cc_physics_RigidBody_setSleepThreshold)); + cls->defineFunction("getSleepThreshold", _SE(js_cc_physics_RigidBody_getSleepThreshold)); + cls->defineFunction("getLinearVelocity", _SE(js_cc_physics_RigidBody_getLinearVelocity)); + cls->defineFunction("setLinearVelocity", _SE(js_cc_physics_RigidBody_setLinearVelocity)); + cls->defineFunction("getAngularVelocity", _SE(js_cc_physics_RigidBody_getAngularVelocity)); + cls->defineFunction("setAngularVelocity", _SE(js_cc_physics_RigidBody_setAngularVelocity)); + cls->defineFunction("applyForce", _SE(js_cc_physics_RigidBody_applyForce)); + cls->defineFunction("applyLocalForce", _SE(js_cc_physics_RigidBody_applyLocalForce)); + cls->defineFunction("applyImpulse", _SE(js_cc_physics_RigidBody_applyImpulse)); + cls->defineFunction("applyLocalImpulse", _SE(js_cc_physics_RigidBody_applyLocalImpulse)); + cls->defineFunction("applyTorque", _SE(js_cc_physics_RigidBody_applyTorque)); + cls->defineFunction("applyLocalTorque", _SE(js_cc_physics_RigidBody_applyLocalTorque)); + cls->defineFunction("getGroup", _SE(js_cc_physics_RigidBody_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_RigidBody_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_RigidBody_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_RigidBody_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_RigidBody_getObjectID)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_RigidBody)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_RigidBody_proto = cls->getProto(); + __jsb_cc_physics_RigidBody_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_SphereShape_class = nullptr; +se::Object* __jsb_cc_physics_SphereShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_SphereShape) + +static bool js_new_cc_physics_SphereShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::SphereShape *result; + result = (cc::physics::SphereShape *)new cc::physics::SphereShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_SphereShape, __jsb_cc_physics_SphereShape_class, js_delete_cc_physics_SphereShape) + +static bool js_delete_cc_physics_SphereShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_SphereShape) + +static bool js_cc_physics_SphereShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_initialize) + +static bool js_cc_physics_SphereShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_onEnable) + +static bool js_cc_physics_SphereShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_onDisable) + +static bool js_cc_physics_SphereShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_onDestroy) + +static bool js_cc_physics_SphereShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setMaterial) + +static bool js_cc_physics_SphereShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setAsTrigger) + +static bool js_cc_physics_SphereShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setCenter) + +static bool js_cc_physics_SphereShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_updateEventListener) + +static bool js_cc_physics_SphereShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_SphereShape_getAABB) + +static bool js_cc_physics_SphereShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_SphereShape_getBoundingSphere) + +static bool js_cc_physics_SphereShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_getGroup) + +static bool js_cc_physics_SphereShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setGroup) + +static bool js_cc_physics_SphereShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_getMask) + +static bool js_cc_physics_SphereShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setMask) + +static bool js_cc_physics_SphereShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::SphereShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_getObjectID) + +static bool js_cc_physics_SphereShape_setRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphereShape *arg1 = (cc::physics::SphereShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphereShape_setRadius) + +bool js_register_cc_physics_SphereShape(se::Object* obj) { + auto* cls = se::Class::create("SphereShape", obj, nullptr, _SE(js_new_cc_physics_SphereShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_SphereShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_SphereShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_SphereShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_SphereShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_SphereShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_SphereShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_SphereShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_SphereShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_SphereShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_SphereShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_SphereShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_SphereShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_SphereShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_SphereShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_SphereShape_getObjectID)); + cls->defineFunction("setRadius", _SE(js_cc_physics_SphereShape_setRadius)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_SphereShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_SphereShape_proto = cls->getProto(); + __jsb_cc_physics_SphereShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_BoxShape_class = nullptr; +se::Object* __jsb_cc_physics_BoxShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_BoxShape) + +static bool js_new_cc_physics_BoxShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::BoxShape *result; + result = (cc::physics::BoxShape *)new cc::physics::BoxShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_BoxShape, __jsb_cc_physics_BoxShape_class, js_delete_cc_physics_BoxShape) + +static bool js_delete_cc_physics_BoxShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_BoxShape) + +static bool js_cc_physics_BoxShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_initialize) + +static bool js_cc_physics_BoxShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_onEnable) + +static bool js_cc_physics_BoxShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_onDisable) + +static bool js_cc_physics_BoxShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_onDestroy) + +static bool js_cc_physics_BoxShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setMaterial) + +static bool js_cc_physics_BoxShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setAsTrigger) + +static bool js_cc_physics_BoxShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setCenter) + +static bool js_cc_physics_BoxShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_updateEventListener) + +static bool js_cc_physics_BoxShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_BoxShape_getAABB) + +static bool js_cc_physics_BoxShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_BoxShape_getBoundingSphere) + +static bool js_cc_physics_BoxShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_getGroup) + +static bool js_cc_physics_BoxShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setGroup) + +static bool js_cc_physics_BoxShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_getMask) + +static bool js_cc_physics_BoxShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setMask) + +static bool js_cc_physics_BoxShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::BoxShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_getObjectID) + +static bool js_cc_physics_BoxShape_setSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxShape *arg1 = (cc::physics::BoxShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxShape_setSize) + +bool js_register_cc_physics_BoxShape(se::Object* obj) { + auto* cls = se::Class::create("BoxShape", obj, nullptr, _SE(js_new_cc_physics_BoxShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_BoxShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_BoxShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_BoxShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_BoxShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_BoxShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_BoxShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_BoxShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_BoxShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_BoxShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_BoxShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_BoxShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_BoxShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_BoxShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_BoxShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_BoxShape_getObjectID)); + cls->defineFunction("setSize", _SE(js_cc_physics_BoxShape_setSize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_BoxShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_BoxShape_proto = cls->getProto(); + __jsb_cc_physics_BoxShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_CapsuleShape_class = nullptr; +se::Object* __jsb_cc_physics_CapsuleShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_CapsuleShape) + +static bool js_new_cc_physics_CapsuleShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::CapsuleShape *result; + result = (cc::physics::CapsuleShape *)new cc::physics::CapsuleShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_CapsuleShape, __jsb_cc_physics_CapsuleShape_class, js_delete_cc_physics_CapsuleShape) + +static bool js_delete_cc_physics_CapsuleShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_CapsuleShape) + +static bool js_cc_physics_CapsuleShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_initialize) + +static bool js_cc_physics_CapsuleShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_onEnable) + +static bool js_cc_physics_CapsuleShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_onDisable) + +static bool js_cc_physics_CapsuleShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_onDestroy) + +static bool js_cc_physics_CapsuleShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setMaterial) + +static bool js_cc_physics_CapsuleShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setAsTrigger) + +static bool js_cc_physics_CapsuleShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setCenter) + +static bool js_cc_physics_CapsuleShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_updateEventListener) + +static bool js_cc_physics_CapsuleShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_CapsuleShape_getAABB) + +static bool js_cc_physics_CapsuleShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_CapsuleShape_getBoundingSphere) + +static bool js_cc_physics_CapsuleShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_getGroup) + +static bool js_cc_physics_CapsuleShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setGroup) + +static bool js_cc_physics_CapsuleShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_getMask) + +static bool js_cc_physics_CapsuleShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setMask) + +static bool js_cc_physics_CapsuleShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::CapsuleShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_getObjectID) + +static bool js_cc_physics_CapsuleShape_setRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setRadius) + +static bool js_cc_physics_CapsuleShape_setCylinderHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCylinderHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setCylinderHeight) + +static bool js_cc_physics_CapsuleShape_setDirection(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleShape *arg1 = (cc::physics::CapsuleShape *) NULL ; + cc::physics::EAxisDirection arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDirection(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleShape_setDirection) + +bool js_register_cc_physics_CapsuleShape(se::Object* obj) { + auto* cls = se::Class::create("CapsuleShape", obj, nullptr, _SE(js_new_cc_physics_CapsuleShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_CapsuleShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_CapsuleShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_CapsuleShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_CapsuleShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_CapsuleShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_CapsuleShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_CapsuleShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_CapsuleShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_CapsuleShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_CapsuleShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_CapsuleShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_CapsuleShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_CapsuleShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_CapsuleShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_CapsuleShape_getObjectID)); + cls->defineFunction("setRadius", _SE(js_cc_physics_CapsuleShape_setRadius)); + cls->defineFunction("setCylinderHeight", _SE(js_cc_physics_CapsuleShape_setCylinderHeight)); + cls->defineFunction("setDirection", _SE(js_cc_physics_CapsuleShape_setDirection)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_CapsuleShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_CapsuleShape_proto = cls->getProto(); + __jsb_cc_physics_CapsuleShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_PlaneShape_class = nullptr; +se::Object* __jsb_cc_physics_PlaneShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_PlaneShape) + +static bool js_new_cc_physics_PlaneShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::PlaneShape *result; + result = (cc::physics::PlaneShape *)new cc::physics::PlaneShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_PlaneShape, __jsb_cc_physics_PlaneShape_class, js_delete_cc_physics_PlaneShape) + +static bool js_delete_cc_physics_PlaneShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_PlaneShape) + +static bool js_cc_physics_PlaneShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_initialize) + +static bool js_cc_physics_PlaneShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_onEnable) + +static bool js_cc_physics_PlaneShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_onDisable) + +static bool js_cc_physics_PlaneShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_onDestroy) + +static bool js_cc_physics_PlaneShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setMaterial) + +static bool js_cc_physics_PlaneShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setAsTrigger) + +static bool js_cc_physics_PlaneShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setCenter) + +static bool js_cc_physics_PlaneShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_updateEventListener) + +static bool js_cc_physics_PlaneShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_PlaneShape_getAABB) + +static bool js_cc_physics_PlaneShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_PlaneShape_getBoundingSphere) + +static bool js_cc_physics_PlaneShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_getGroup) + +static bool js_cc_physics_PlaneShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setGroup) + +static bool js_cc_physics_PlaneShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_getMask) + +static bool js_cc_physics_PlaneShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setMask) + +static bool js_cc_physics_PlaneShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::PlaneShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_getObjectID) + +static bool js_cc_physics_PlaneShape_setConstant(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setConstant(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setConstant) + +static bool js_cc_physics_PlaneShape_setNormal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::PlaneShape *arg1 = (cc::physics::PlaneShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setNormal(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_PlaneShape_setNormal) + +bool js_register_cc_physics_PlaneShape(se::Object* obj) { + auto* cls = se::Class::create("PlaneShape", obj, nullptr, _SE(js_new_cc_physics_PlaneShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_PlaneShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_PlaneShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_PlaneShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_PlaneShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_PlaneShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_PlaneShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_PlaneShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_PlaneShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_PlaneShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_PlaneShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_PlaneShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_PlaneShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_PlaneShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_PlaneShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_PlaneShape_getObjectID)); + cls->defineFunction("setConstant", _SE(js_cc_physics_PlaneShape_setConstant)); + cls->defineFunction("setNormal", _SE(js_cc_physics_PlaneShape_setNormal)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_PlaneShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_PlaneShape_proto = cls->getProto(); + __jsb_cc_physics_PlaneShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_TrimeshShape_class = nullptr; +se::Object* __jsb_cc_physics_TrimeshShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_TrimeshShape) + +static bool js_new_cc_physics_TrimeshShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::TrimeshShape *result; + result = (cc::physics::TrimeshShape *)new cc::physics::TrimeshShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_TrimeshShape, __jsb_cc_physics_TrimeshShape_class, js_delete_cc_physics_TrimeshShape) + +static bool js_delete_cc_physics_TrimeshShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_TrimeshShape) + +static bool js_cc_physics_TrimeshShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_initialize) + +static bool js_cc_physics_TrimeshShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_onEnable) + +static bool js_cc_physics_TrimeshShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_onDisable) + +static bool js_cc_physics_TrimeshShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_onDestroy) + +static bool js_cc_physics_TrimeshShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setMaterial) + +static bool js_cc_physics_TrimeshShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setAsTrigger) + +static bool js_cc_physics_TrimeshShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setCenter) + +static bool js_cc_physics_TrimeshShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_updateEventListener) + +static bool js_cc_physics_TrimeshShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_TrimeshShape_getAABB) + +static bool js_cc_physics_TrimeshShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_TrimeshShape_getBoundingSphere) + +static bool js_cc_physics_TrimeshShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_getGroup) + +static bool js_cc_physics_TrimeshShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setGroup) + +static bool js_cc_physics_TrimeshShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_getMask) + +static bool js_cc_physics_TrimeshShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setMask) + +static bool js_cc_physics_TrimeshShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::TrimeshShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_getObjectID) + +static bool js_cc_physics_TrimeshShape_setMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMesh(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_setMesh) + +static bool js_cc_physics_TrimeshShape_useConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TrimeshShape *arg1 = (cc::physics::TrimeshShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useConvex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TrimeshShape_useConvex) + +bool js_register_cc_physics_TrimeshShape(se::Object* obj) { + auto* cls = se::Class::create("TrimeshShape", obj, nullptr, _SE(js_new_cc_physics_TrimeshShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_TrimeshShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_TrimeshShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_TrimeshShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_TrimeshShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_TrimeshShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_TrimeshShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_TrimeshShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_TrimeshShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_TrimeshShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_TrimeshShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_TrimeshShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_TrimeshShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_TrimeshShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_TrimeshShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_TrimeshShape_getObjectID)); + cls->defineFunction("setMesh", _SE(js_cc_physics_TrimeshShape_setMesh)); + cls->defineFunction("useConvex", _SE(js_cc_physics_TrimeshShape_useConvex)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_TrimeshShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_TrimeshShape_proto = cls->getProto(); + __jsb_cc_physics_TrimeshShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_CylinderShape_class = nullptr; +se::Object* __jsb_cc_physics_CylinderShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_CylinderShape) + +static bool js_new_cc_physics_CylinderShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::CylinderShape *result; + result = (cc::physics::CylinderShape *)new cc::physics::CylinderShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_CylinderShape, __jsb_cc_physics_CylinderShape_class, js_delete_cc_physics_CylinderShape) + +static bool js_delete_cc_physics_CylinderShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_CylinderShape) + +static bool js_cc_physics_CylinderShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_initialize) + +static bool js_cc_physics_CylinderShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_onEnable) + +static bool js_cc_physics_CylinderShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_onDisable) + +static bool js_cc_physics_CylinderShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_onDestroy) + +static bool js_cc_physics_CylinderShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setMaterial) + +static bool js_cc_physics_CylinderShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setAsTrigger) + +static bool js_cc_physics_CylinderShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setCenter) + +static bool js_cc_physics_CylinderShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_updateEventListener) + +static bool js_cc_physics_CylinderShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_CylinderShape_getAABB) + +static bool js_cc_physics_CylinderShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_CylinderShape_getBoundingSphere) + +static bool js_cc_physics_CylinderShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_getGroup) + +static bool js_cc_physics_CylinderShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setGroup) + +static bool js_cc_physics_CylinderShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_getMask) + +static bool js_cc_physics_CylinderShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setMask) + +static bool js_cc_physics_CylinderShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::CylinderShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_getObjectID) + +static bool js_cc_physics_CylinderShape_setConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConvex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setConvex) + +static bool js_cc_physics_CylinderShape_setCylinder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CylinderShape *arg1 = (cc::physics::CylinderShape *) NULL ; + float arg2 ; + float arg3 ; + cc::physics::EAxisDirection arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCylinder(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CylinderShape_setCylinder) + +bool js_register_cc_physics_CylinderShape(se::Object* obj) { + auto* cls = se::Class::create("CylinderShape", obj, nullptr, _SE(js_new_cc_physics_CylinderShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_CylinderShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_CylinderShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_CylinderShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_CylinderShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_CylinderShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_CylinderShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_CylinderShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_CylinderShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_CylinderShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_CylinderShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_CylinderShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_CylinderShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_CylinderShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_CylinderShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_CylinderShape_getObjectID)); + cls->defineFunction("setConvex", _SE(js_cc_physics_CylinderShape_setConvex)); + cls->defineFunction("setCylinder", _SE(js_cc_physics_CylinderShape_setCylinder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_CylinderShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_CylinderShape_proto = cls->getProto(); + __jsb_cc_physics_CylinderShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_ConeShape_class = nullptr; +se::Object* __jsb_cc_physics_ConeShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_ConeShape) + +static bool js_new_cc_physics_ConeShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::ConeShape *result; + result = (cc::physics::ConeShape *)new cc::physics::ConeShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_ConeShape, __jsb_cc_physics_ConeShape_class, js_delete_cc_physics_ConeShape) + +static bool js_delete_cc_physics_ConeShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_ConeShape) + +static bool js_cc_physics_ConeShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_initialize) + +static bool js_cc_physics_ConeShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_onEnable) + +static bool js_cc_physics_ConeShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_onDisable) + +static bool js_cc_physics_ConeShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_onDestroy) + +static bool js_cc_physics_ConeShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setMaterial) + +static bool js_cc_physics_ConeShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setAsTrigger) + +static bool js_cc_physics_ConeShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setCenter) + +static bool js_cc_physics_ConeShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_updateEventListener) + +static bool js_cc_physics_ConeShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_ConeShape_getAABB) + +static bool js_cc_physics_ConeShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_ConeShape_getBoundingSphere) + +static bool js_cc_physics_ConeShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_getGroup) + +static bool js_cc_physics_ConeShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setGroup) + +static bool js_cc_physics_ConeShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_getMask) + +static bool js_cc_physics_ConeShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setMask) + +static bool js_cc_physics_ConeShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::ConeShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_getObjectID) + +static bool js_cc_physics_ConeShape_setConvex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConvex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setConvex) + +static bool js_cc_physics_ConeShape_setCone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::ConeShape *arg1 = (cc::physics::ConeShape *) NULL ; + float arg2 ; + float arg3 ; + cc::physics::EAxisDirection arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCone(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_ConeShape_setCone) + +bool js_register_cc_physics_ConeShape(se::Object* obj) { + auto* cls = se::Class::create("ConeShape", obj, nullptr, _SE(js_new_cc_physics_ConeShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_ConeShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_ConeShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_ConeShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_ConeShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_ConeShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_ConeShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_ConeShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_ConeShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_ConeShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_ConeShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_ConeShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_ConeShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_ConeShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_ConeShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_ConeShape_getObjectID)); + cls->defineFunction("setConvex", _SE(js_cc_physics_ConeShape_setConvex)); + cls->defineFunction("setCone", _SE(js_cc_physics_ConeShape_setCone)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_ConeShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_ConeShape_proto = cls->getProto(); + __jsb_cc_physics_ConeShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_TerrainShape_class = nullptr; +se::Object* __jsb_cc_physics_TerrainShape_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_TerrainShape) + +static bool js_new_cc_physics_TerrainShape(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::TerrainShape *result; + result = (cc::physics::TerrainShape *)new cc::physics::TerrainShape(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_TerrainShape, __jsb_cc_physics_TerrainShape_class, js_delete_cc_physics_TerrainShape) + +static bool js_delete_cc_physics_TerrainShape(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_TerrainShape) + +static bool js_cc_physics_TerrainShape_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_initialize) + +static bool js_cc_physics_TerrainShape_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_onEnable) + +static bool js_cc_physics_TerrainShape_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_onDisable) + +static bool js_cc_physics_TerrainShape_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_onDestroy) + +static bool js_cc_physics_TerrainShape_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint16_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + uint8_t arg6 ; + uint8_t arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaterial(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setMaterial) + +static bool js_cc_physics_TerrainShape_setAsTrigger(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAsTrigger(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setAsTrigger) + +static bool js_cc_physics_TerrainShape_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setCenter) + +static bool js_cc_physics_TerrainShape_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_updateEventListener) + +static bool js_cc_physics_TerrainShape_getAABB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &(arg1)->getAABB(); + + 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_physics_TerrainShape_getAABB) + +static bool js_cc_physics_TerrainShape_getBoundingSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + cc::geometry::Sphere *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(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Sphere *) &(arg1)->getBoundingSphere(); + + 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_physics_TerrainShape_getBoundingSphere) + +static bool js_cc_physics_TerrainShape_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_getGroup) + +static bool js_cc_physics_TerrainShape_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setGroup) + +static bool js_cc_physics_TerrainShape_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_getMask) + +static bool js_cc_physics_TerrainShape_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setMask) + +static bool js_cc_physics_TerrainShape_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::TerrainShape const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_getObjectID) + +static bool js_cc_physics_TerrainShape_setTerrain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::TerrainShape *arg1 = (cc::physics::TerrainShape *) NULL ; + uint32_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setTerrain(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_TerrainShape_setTerrain) + +bool js_register_cc_physics_TerrainShape(se::Object* obj) { + auto* cls = se::Class::create("TerrainShape", obj, nullptr, _SE(js_new_cc_physics_TerrainShape)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_TerrainShape_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_TerrainShape_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_TerrainShape_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_TerrainShape_onDestroy)); + cls->defineFunction("setMaterial", _SE(js_cc_physics_TerrainShape_setMaterial)); + cls->defineFunction("setAsTrigger", _SE(js_cc_physics_TerrainShape_setAsTrigger)); + cls->defineFunction("setCenter", _SE(js_cc_physics_TerrainShape_setCenter)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_TerrainShape_updateEventListener)); + cls->defineFunction("getAABB", _SE(js_cc_physics_TerrainShape_getAABB)); + cls->defineFunction("getBoundingSphere", _SE(js_cc_physics_TerrainShape_getBoundingSphere)); + cls->defineFunction("getGroup", _SE(js_cc_physics_TerrainShape_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_TerrainShape_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_TerrainShape_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_TerrainShape_setMask)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_TerrainShape_getObjectID)); + cls->defineFunction("setTerrain", _SE(js_cc_physics_TerrainShape_setTerrain)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_TerrainShape)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_TerrainShape_proto = cls->getProto(); + __jsb_cc_physics_TerrainShape_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_RevoluteJoint_class = nullptr; +se::Object* __jsb_cc_physics_RevoluteJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_RevoluteJoint) + +static bool js_new_cc_physics_RevoluteJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::RevoluteJoint *result; + result = (cc::physics::RevoluteJoint *)new cc::physics::RevoluteJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_RevoluteJoint, __jsb_cc_physics_RevoluteJoint_class, js_delete_cc_physics_RevoluteJoint) + +static bool js_delete_cc_physics_RevoluteJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_RevoluteJoint) + +static bool js_cc_physics_RevoluteJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_initialize) + +static bool js_cc_physics_RevoluteJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_onEnable) + +static bool js_cc_physics_RevoluteJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_onDisable) + +static bool js_cc_physics_RevoluteJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_onDestroy) + +static bool js_cc_physics_RevoluteJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setEnableCollision) + +static bool js_cc_physics_RevoluteJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setConnectedBody) + +static bool js_cc_physics_RevoluteJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::RevoluteJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_getObjectID) + +static bool js_cc_physics_RevoluteJoint_setPivotA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotA(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setPivotA) + +static bool js_cc_physics_RevoluteJoint_setPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotB(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setPivotB) + +static bool js_cc_physics_RevoluteJoint_setAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAxis(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setAxis) + +static bool js_cc_physics_RevoluteJoint_setLimitEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLimitEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setLimitEnabled) + +static bool js_cc_physics_RevoluteJoint_setLowerLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLowerLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setLowerLimit) + +static bool js_cc_physics_RevoluteJoint_setUpperLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUpperLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setUpperLimit) + +static bool js_cc_physics_RevoluteJoint_setMotorEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMotorEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setMotorEnabled) + +static bool js_cc_physics_RevoluteJoint_setMotorVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMotorVelocity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setMotorVelocity) + +static bool js_cc_physics_RevoluteJoint_setMotorForceLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::RevoluteJoint *arg1 = (cc::physics::RevoluteJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMotorForceLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_RevoluteJoint_setMotorForceLimit) + +bool js_register_cc_physics_RevoluteJoint(se::Object* obj) { + auto* cls = se::Class::create("RevoluteJoint", obj, nullptr, _SE(js_new_cc_physics_RevoluteJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_RevoluteJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_RevoluteJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_RevoluteJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_RevoluteJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_RevoluteJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_RevoluteJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_RevoluteJoint_getObjectID)); + cls->defineFunction("setPivotA", _SE(js_cc_physics_RevoluteJoint_setPivotA)); + cls->defineFunction("setPivotB", _SE(js_cc_physics_RevoluteJoint_setPivotB)); + cls->defineFunction("setAxis", _SE(js_cc_physics_RevoluteJoint_setAxis)); + cls->defineFunction("setLimitEnabled", _SE(js_cc_physics_RevoluteJoint_setLimitEnabled)); + cls->defineFunction("setLowerLimit", _SE(js_cc_physics_RevoluteJoint_setLowerLimit)); + cls->defineFunction("setUpperLimit", _SE(js_cc_physics_RevoluteJoint_setUpperLimit)); + cls->defineFunction("setMotorEnabled", _SE(js_cc_physics_RevoluteJoint_setMotorEnabled)); + cls->defineFunction("setMotorVelocity", _SE(js_cc_physics_RevoluteJoint_setMotorVelocity)); + cls->defineFunction("setMotorForceLimit", _SE(js_cc_physics_RevoluteJoint_setMotorForceLimit)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_RevoluteJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_RevoluteJoint_proto = cls->getProto(); + __jsb_cc_physics_RevoluteJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_SphericalJoint_class = nullptr; +se::Object* __jsb_cc_physics_SphericalJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_SphericalJoint) + +static bool js_new_cc_physics_SphericalJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::SphericalJoint *result; + result = (cc::physics::SphericalJoint *)new cc::physics::SphericalJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_SphericalJoint, __jsb_cc_physics_SphericalJoint_class, js_delete_cc_physics_SphericalJoint) + +static bool js_delete_cc_physics_SphericalJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_SphericalJoint) + +static bool js_cc_physics_SphericalJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_initialize) + +static bool js_cc_physics_SphericalJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_onEnable) + +static bool js_cc_physics_SphericalJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_onDisable) + +static bool js_cc_physics_SphericalJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_onDestroy) + +static bool js_cc_physics_SphericalJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setEnableCollision) + +static bool js_cc_physics_SphericalJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setConnectedBody) + +static bool js_cc_physics_SphericalJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::SphericalJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_getObjectID) + +static bool js_cc_physics_SphericalJoint_setPivotA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotA(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setPivotA) + +static bool js_cc_physics_SphericalJoint_setPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::SphericalJoint *arg1 = (cc::physics::SphericalJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotB(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_SphericalJoint_setPivotB) + +bool js_register_cc_physics_SphericalJoint(se::Object* obj) { + auto* cls = se::Class::create("SphericalJoint", obj, nullptr, _SE(js_new_cc_physics_SphericalJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_SphericalJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_SphericalJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_SphericalJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_SphericalJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_SphericalJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_SphericalJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_SphericalJoint_getObjectID)); + cls->defineFunction("setPivotA", _SE(js_cc_physics_SphericalJoint_setPivotA)); + cls->defineFunction("setPivotB", _SE(js_cc_physics_SphericalJoint_setPivotB)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_SphericalJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_SphericalJoint_proto = cls->getProto(); + __jsb_cc_physics_SphericalJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_FixedJoint_class = nullptr; +se::Object* __jsb_cc_physics_FixedJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_FixedJoint) + +static bool js_new_cc_physics_FixedJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::FixedJoint *result; + result = (cc::physics::FixedJoint *)new cc::physics::FixedJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_FixedJoint, __jsb_cc_physics_FixedJoint_class, js_delete_cc_physics_FixedJoint) + +static bool js_delete_cc_physics_FixedJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_FixedJoint) + +static bool js_cc_physics_FixedJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_initialize) + +static bool js_cc_physics_FixedJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_onEnable) + +static bool js_cc_physics_FixedJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_onDisable) + +static bool js_cc_physics_FixedJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_onDestroy) + +static bool js_cc_physics_FixedJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setEnableCollision) + +static bool js_cc_physics_FixedJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setConnectedBody) + +static bool js_cc_physics_FixedJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::FixedJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_getObjectID) + +static bool js_cc_physics_FixedJoint_setBreakForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setBreakForce) + +static bool js_cc_physics_FixedJoint_setBreakTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::FixedJoint *arg1 = (cc::physics::FixedJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_FixedJoint_setBreakTorque) + +bool js_register_cc_physics_FixedJoint(se::Object* obj) { + auto* cls = se::Class::create("FixedJoint", obj, nullptr, _SE(js_new_cc_physics_FixedJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_FixedJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_FixedJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_FixedJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_FixedJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_FixedJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_FixedJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_FixedJoint_getObjectID)); + cls->defineFunction("setBreakForce", _SE(js_cc_physics_FixedJoint_setBreakForce)); + cls->defineFunction("setBreakTorque", _SE(js_cc_physics_FixedJoint_setBreakTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_FixedJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_FixedJoint_proto = cls->getProto(); + __jsb_cc_physics_FixedJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_GenericJoint_class = nullptr; +se::Object* __jsb_cc_physics_GenericJoint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_GenericJoint) + +static bool js_new_cc_physics_GenericJoint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::GenericJoint *result; + result = (cc::physics::GenericJoint *)new cc::physics::GenericJoint(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_GenericJoint, __jsb_cc_physics_GenericJoint_class, js_delete_cc_physics_GenericJoint) + +static bool js_delete_cc_physics_GenericJoint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_GenericJoint) + +static bool js_cc_physics_GenericJoint_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_initialize) + +static bool js_cc_physics_GenericJoint_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_onEnable) + +static bool js_cc_physics_GenericJoint_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_onDisable) + +static bool js_cc_physics_GenericJoint_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_onDestroy) + +static bool js_cc_physics_GenericJoint_setEnableCollision(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnableCollision(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setEnableCollision) + +static bool js_cc_physics_GenericJoint_setConnectedBody(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setConnectedBody(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setConnectedBody) + +static bool js_cc_physics_GenericJoint_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::GenericJoint const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_getObjectID) + +static bool js_cc_physics_GenericJoint_setConstraintMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setConstraintMode(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setConstraintMode) + +static bool js_cc_physics_GenericJoint_setLinearLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearLimit(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearLimit) + +static bool js_cc_physics_GenericJoint_setAngularExtent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularExtent(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularExtent) + +static bool js_cc_physics_GenericJoint_setLinearSoftConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearSoftConstraint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearSoftConstraint) + +static bool js_cc_physics_GenericJoint_setLinearStiffness(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearStiffness(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearStiffness) + +static bool js_cc_physics_GenericJoint_setLinearDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearDamping) + +static bool js_cc_physics_GenericJoint_setLinearRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearRestitution) + +static bool js_cc_physics_GenericJoint_setSwingSoftConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingSoftConstraint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingSoftConstraint) + +static bool js_cc_physics_GenericJoint_setTwistSoftConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistSoftConstraint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistSoftConstraint) + +static bool js_cc_physics_GenericJoint_setSwingStiffness(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingStiffness(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingStiffness) + +static bool js_cc_physics_GenericJoint_setSwingDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingDamping) + +static bool js_cc_physics_GenericJoint_setSwingRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSwingRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSwingRestitution) + +static bool js_cc_physics_GenericJoint_setTwistStiffness(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistStiffness(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistStiffness) + +static bool js_cc_physics_GenericJoint_setTwistDamping(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistDamping(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistDamping) + +static bool js_cc_physics_GenericJoint_setTwistRestitution(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTwistRestitution(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setTwistRestitution) + +static bool js_cc_physics_GenericJoint_setDriverMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDriverMode(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setDriverMode) + +static bool js_cc_physics_GenericJoint_setLinearMotorTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearMotorTarget(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearMotorTarget) + +static bool js_cc_physics_GenericJoint_setLinearMotorVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setLinearMotorVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearMotorVelocity) + +static bool js_cc_physics_GenericJoint_setLinearMotorForceLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLinearMotorForceLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setLinearMotorForceLimit) + +static bool js_cc_physics_GenericJoint_setAngularMotorTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularMotorTarget(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularMotorTarget) + +static bool js_cc_physics_GenericJoint_setAngularMotorVelocity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAngularMotorVelocity(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularMotorVelocity) + +static bool js_cc_physics_GenericJoint_setAngularMotorForceLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAngularMotorForceLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAngularMotorForceLimit) + +static bool js_cc_physics_GenericJoint_setPivotA(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotA(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setPivotA) + +static bool js_cc_physics_GenericJoint_setPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPivotB(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setPivotB) + +static bool js_cc_physics_GenericJoint_setAutoPivotB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAutoPivotB(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAutoPivotB) + +static bool js_cc_physics_GenericJoint_setAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setAxis(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setAxis) + +static bool js_cc_physics_GenericJoint_setSecondaryAxis(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSecondaryAxis(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setSecondaryAxis) + +static bool js_cc_physics_GenericJoint_setBreakForce(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakForce(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setBreakForce) + +static bool js_cc_physics_GenericJoint_setBreakTorque(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::GenericJoint *arg1 = (cc::physics::GenericJoint *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBreakTorque(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_GenericJoint_setBreakTorque) + +bool js_register_cc_physics_GenericJoint(se::Object* obj) { + auto* cls = se::Class::create("GenericJoint", obj, nullptr, _SE(js_new_cc_physics_GenericJoint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_GenericJoint_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_GenericJoint_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_GenericJoint_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_GenericJoint_onDestroy)); + cls->defineFunction("setEnableCollision", _SE(js_cc_physics_GenericJoint_setEnableCollision)); + cls->defineFunction("setConnectedBody", _SE(js_cc_physics_GenericJoint_setConnectedBody)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_GenericJoint_getObjectID)); + cls->defineFunction("setConstraintMode", _SE(js_cc_physics_GenericJoint_setConstraintMode)); + cls->defineFunction("setLinearLimit", _SE(js_cc_physics_GenericJoint_setLinearLimit)); + cls->defineFunction("setAngularExtent", _SE(js_cc_physics_GenericJoint_setAngularExtent)); + cls->defineFunction("setLinearSoftConstraint", _SE(js_cc_physics_GenericJoint_setLinearSoftConstraint)); + cls->defineFunction("setLinearStiffness", _SE(js_cc_physics_GenericJoint_setLinearStiffness)); + cls->defineFunction("setLinearDamping", _SE(js_cc_physics_GenericJoint_setLinearDamping)); + cls->defineFunction("setLinearRestitution", _SE(js_cc_physics_GenericJoint_setLinearRestitution)); + cls->defineFunction("setSwingSoftConstraint", _SE(js_cc_physics_GenericJoint_setSwingSoftConstraint)); + cls->defineFunction("setTwistSoftConstraint", _SE(js_cc_physics_GenericJoint_setTwistSoftConstraint)); + cls->defineFunction("setSwingStiffness", _SE(js_cc_physics_GenericJoint_setSwingStiffness)); + cls->defineFunction("setSwingDamping", _SE(js_cc_physics_GenericJoint_setSwingDamping)); + cls->defineFunction("setSwingRestitution", _SE(js_cc_physics_GenericJoint_setSwingRestitution)); + cls->defineFunction("setTwistStiffness", _SE(js_cc_physics_GenericJoint_setTwistStiffness)); + cls->defineFunction("setTwistDamping", _SE(js_cc_physics_GenericJoint_setTwistDamping)); + cls->defineFunction("setTwistRestitution", _SE(js_cc_physics_GenericJoint_setTwistRestitution)); + cls->defineFunction("setDriverMode", _SE(js_cc_physics_GenericJoint_setDriverMode)); + cls->defineFunction("setLinearMotorTarget", _SE(js_cc_physics_GenericJoint_setLinearMotorTarget)); + cls->defineFunction("setLinearMotorVelocity", _SE(js_cc_physics_GenericJoint_setLinearMotorVelocity)); + cls->defineFunction("setLinearMotorForceLimit", _SE(js_cc_physics_GenericJoint_setLinearMotorForceLimit)); + cls->defineFunction("setAngularMotorTarget", _SE(js_cc_physics_GenericJoint_setAngularMotorTarget)); + cls->defineFunction("setAngularMotorVelocity", _SE(js_cc_physics_GenericJoint_setAngularMotorVelocity)); + cls->defineFunction("setAngularMotorForceLimit", _SE(js_cc_physics_GenericJoint_setAngularMotorForceLimit)); + cls->defineFunction("setPivotA", _SE(js_cc_physics_GenericJoint_setPivotA)); + cls->defineFunction("setPivotB", _SE(js_cc_physics_GenericJoint_setPivotB)); + cls->defineFunction("setAutoPivotB", _SE(js_cc_physics_GenericJoint_setAutoPivotB)); + cls->defineFunction("setAxis", _SE(js_cc_physics_GenericJoint_setAxis)); + cls->defineFunction("setSecondaryAxis", _SE(js_cc_physics_GenericJoint_setSecondaryAxis)); + cls->defineFunction("setBreakForce", _SE(js_cc_physics_GenericJoint_setBreakForce)); + cls->defineFunction("setBreakTorque", _SE(js_cc_physics_GenericJoint_setBreakTorque)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_GenericJoint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_GenericJoint_proto = cls->getProto(); + __jsb_cc_physics_GenericJoint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_CapsuleCharacterController_class = nullptr; +se::Object* __jsb_cc_physics_CapsuleCharacterController_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_CapsuleCharacterController) + +static bool js_new_cc_physics_CapsuleCharacterController(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::CapsuleCharacterController *result; + result = (cc::physics::CapsuleCharacterController *)new cc::physics::CapsuleCharacterController(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_CapsuleCharacterController, __jsb_cc_physics_CapsuleCharacterController_class, js_delete_cc_physics_CapsuleCharacterController) + +static bool js_delete_cc_physics_CapsuleCharacterController(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_CapsuleCharacterController) + +static bool js_cc_physics_CapsuleCharacterController_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_initialize) + +static bool js_cc_physics_CapsuleCharacterController_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onEnable) + +static bool js_cc_physics_CapsuleCharacterController_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onDisable) + +static bool js_cc_physics_CapsuleCharacterController_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onDestroy) + +static bool js_cc_physics_CapsuleCharacterController_getPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getPosition(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getPosition) + +static bool js_cc_physics_CapsuleCharacterController_setPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPosition(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setPosition) + +static bool js_cc_physics_CapsuleCharacterController_onGround(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onGround(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_onGround) + +static bool js_cc_physics_CapsuleCharacterController_move(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->move(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_move) + +static bool js_cc_physics_CapsuleCharacterController_syncPhysicsToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncPhysicsToScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_syncPhysicsToScene) + +static bool js_cc_physics_CapsuleCharacterController_setStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setStepOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setStepOffset) + +static bool js_cc_physics_CapsuleCharacterController_getStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getStepOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getStepOffset) + +static bool js_cc_physics_CapsuleCharacterController_setSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSlopeLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setSlopeLimit) + +static bool js_cc_physics_CapsuleCharacterController_getSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getSlopeLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getSlopeLimit) + +static bool js_cc_physics_CapsuleCharacterController_setContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setContactOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setContactOffset) + +static bool js_cc_physics_CapsuleCharacterController_getContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getContactOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getContactOffset) + +static bool js_cc_physics_CapsuleCharacterController_setDetectCollisions(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDetectCollisions(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setDetectCollisions) + +static bool js_cc_physics_CapsuleCharacterController_setOverlapRecovery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOverlapRecovery(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setOverlapRecovery) + +static bool js_cc_physics_CapsuleCharacterController_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setCenter) + +static bool js_cc_physics_CapsuleCharacterController_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getGroup) + +static bool js_cc_physics_CapsuleCharacterController_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setGroup) + +static bool js_cc_physics_CapsuleCharacterController_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getMask) + +static bool js_cc_physics_CapsuleCharacterController_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setMask) + +static bool js_cc_physics_CapsuleCharacterController_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_updateEventListener) + +static bool js_cc_physics_CapsuleCharacterController_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::CapsuleCharacterController const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_getObjectID) + +static bool js_cc_physics_CapsuleCharacterController_setRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setRadius) + +static bool js_cc_physics_CapsuleCharacterController_setHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::CapsuleCharacterController *arg1 = (cc::physics::CapsuleCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_CapsuleCharacterController_setHeight) + +bool js_register_cc_physics_CapsuleCharacterController(se::Object* obj) { + auto* cls = se::Class::create("CapsuleCharacterController", obj, nullptr, _SE(js_new_cc_physics_CapsuleCharacterController)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_CapsuleCharacterController_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_CapsuleCharacterController_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_CapsuleCharacterController_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_CapsuleCharacterController_onDestroy)); + cls->defineFunction("getPosition", _SE(js_cc_physics_CapsuleCharacterController_getPosition)); + cls->defineFunction("setPosition", _SE(js_cc_physics_CapsuleCharacterController_setPosition)); + cls->defineFunction("onGround", _SE(js_cc_physics_CapsuleCharacterController_onGround)); + cls->defineFunction("move", _SE(js_cc_physics_CapsuleCharacterController_move)); + cls->defineFunction("syncPhysicsToScene", _SE(js_cc_physics_CapsuleCharacterController_syncPhysicsToScene)); + cls->defineFunction("setStepOffset", _SE(js_cc_physics_CapsuleCharacterController_setStepOffset)); + cls->defineFunction("getStepOffset", _SE(js_cc_physics_CapsuleCharacterController_getStepOffset)); + cls->defineFunction("setSlopeLimit", _SE(js_cc_physics_CapsuleCharacterController_setSlopeLimit)); + cls->defineFunction("getSlopeLimit", _SE(js_cc_physics_CapsuleCharacterController_getSlopeLimit)); + cls->defineFunction("setContactOffset", _SE(js_cc_physics_CapsuleCharacterController_setContactOffset)); + cls->defineFunction("getContactOffset", _SE(js_cc_physics_CapsuleCharacterController_getContactOffset)); + cls->defineFunction("setDetectCollisions", _SE(js_cc_physics_CapsuleCharacterController_setDetectCollisions)); + cls->defineFunction("setOverlapRecovery", _SE(js_cc_physics_CapsuleCharacterController_setOverlapRecovery)); + cls->defineFunction("setCenter", _SE(js_cc_physics_CapsuleCharacterController_setCenter)); + cls->defineFunction("getGroup", _SE(js_cc_physics_CapsuleCharacterController_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_CapsuleCharacterController_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_CapsuleCharacterController_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_CapsuleCharacterController_setMask)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_CapsuleCharacterController_updateEventListener)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_CapsuleCharacterController_getObjectID)); + cls->defineFunction("setRadius", _SE(js_cc_physics_CapsuleCharacterController_setRadius)); + cls->defineFunction("setHeight", _SE(js_cc_physics_CapsuleCharacterController_setHeight)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_CapsuleCharacterController)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_CapsuleCharacterController_proto = cls->getProto(); + __jsb_cc_physics_CapsuleCharacterController_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_physics_BoxCharacterController_class = nullptr; +se::Object* __jsb_cc_physics_BoxCharacterController_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_physics_BoxCharacterController) + +static bool js_new_cc_physics_BoxCharacterController(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::physics::BoxCharacterController *result; + result = (cc::physics::BoxCharacterController *)new cc::physics::BoxCharacterController(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_physics_BoxCharacterController, __jsb_cc_physics_BoxCharacterController_class, js_delete_cc_physics_BoxCharacterController) + +static bool js_delete_cc_physics_BoxCharacterController(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_physics_BoxCharacterController) + +static bool js_cc_physics_BoxCharacterController_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_initialize) + +static bool js_cc_physics_BoxCharacterController_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onEnable) + +static bool js_cc_physics_BoxCharacterController_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onDisable) + +static bool js_cc_physics_BoxCharacterController_onDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDestroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onDestroy) + +static bool js_cc_physics_BoxCharacterController_getPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getPosition(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getPosition) + +static bool js_cc_physics_BoxCharacterController_setPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPosition(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setPosition) + +static bool js_cc_physics_BoxCharacterController_onGround(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onGround(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_onGround) + +static bool js_cc_physics_BoxCharacterController_move(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->move(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_move) + +static bool js_cc_physics_BoxCharacterController_syncPhysicsToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->syncPhysicsToScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_syncPhysicsToScene) + +static bool js_cc_physics_BoxCharacterController_setStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setStepOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setStepOffset) + +static bool js_cc_physics_BoxCharacterController_getStepOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getStepOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getStepOffset) + +static bool js_cc_physics_BoxCharacterController_setSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSlopeLimit(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setSlopeLimit) + +static bool js_cc_physics_BoxCharacterController_getSlopeLimit(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getSlopeLimit(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getSlopeLimit) + +static bool js_cc_physics_BoxCharacterController_setContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setContactOffset(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setContactOffset) + +static bool js_cc_physics_BoxCharacterController_getContactOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getContactOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getContactOffset) + +static bool js_cc_physics_BoxCharacterController_setDetectCollisions(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDetectCollisions(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setDetectCollisions) + +static bool js_cc_physics_BoxCharacterController_setOverlapRecovery(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOverlapRecovery(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setOverlapRecovery) + +static bool js_cc_physics_BoxCharacterController_setCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCenter(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setCenter) + +static bool js_cc_physics_BoxCharacterController_getGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getGroup(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getGroup) + +static bool js_cc_physics_BoxCharacterController_setGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setGroup) + +static bool js_cc_physics_BoxCharacterController_getMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getMask(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getMask) + +static bool js_cc_physics_BoxCharacterController_setMask(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMask(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setMask) + +static bool js_cc_physics_BoxCharacterController_updateEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + cc::physics::EShapeFilterFlag arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateEventListener(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_updateEventListener) + +static bool js_cc_physics_BoxCharacterController_getObjectID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::physics::BoxCharacterController const *)arg1)->getObjectID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_getObjectID) + +static bool js_cc_physics_BoxCharacterController_setHalfHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHalfHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setHalfHeight) + +static bool js_cc_physics_BoxCharacterController_setHalfSideExtent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHalfSideExtent(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setHalfSideExtent) + +static bool js_cc_physics_BoxCharacterController_setHalfForwardExtent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::physics::BoxCharacterController *arg1 = (cc::physics::BoxCharacterController *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHalfForwardExtent(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_physics_BoxCharacterController_setHalfForwardExtent) + +bool js_register_cc_physics_BoxCharacterController(se::Object* obj) { + auto* cls = se::Class::create("BoxCharacterController", obj, nullptr, _SE(js_new_cc_physics_BoxCharacterController)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_physics_BoxCharacterController_initialize)); + cls->defineFunction("onEnable", _SE(js_cc_physics_BoxCharacterController_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_physics_BoxCharacterController_onDisable)); + cls->defineFunction("onDestroy", _SE(js_cc_physics_BoxCharacterController_onDestroy)); + cls->defineFunction("getPosition", _SE(js_cc_physics_BoxCharacterController_getPosition)); + cls->defineFunction("setPosition", _SE(js_cc_physics_BoxCharacterController_setPosition)); + cls->defineFunction("onGround", _SE(js_cc_physics_BoxCharacterController_onGround)); + cls->defineFunction("move", _SE(js_cc_physics_BoxCharacterController_move)); + cls->defineFunction("syncPhysicsToScene", _SE(js_cc_physics_BoxCharacterController_syncPhysicsToScene)); + cls->defineFunction("setStepOffset", _SE(js_cc_physics_BoxCharacterController_setStepOffset)); + cls->defineFunction("getStepOffset", _SE(js_cc_physics_BoxCharacterController_getStepOffset)); + cls->defineFunction("setSlopeLimit", _SE(js_cc_physics_BoxCharacterController_setSlopeLimit)); + cls->defineFunction("getSlopeLimit", _SE(js_cc_physics_BoxCharacterController_getSlopeLimit)); + cls->defineFunction("setContactOffset", _SE(js_cc_physics_BoxCharacterController_setContactOffset)); + cls->defineFunction("getContactOffset", _SE(js_cc_physics_BoxCharacterController_getContactOffset)); + cls->defineFunction("setDetectCollisions", _SE(js_cc_physics_BoxCharacterController_setDetectCollisions)); + cls->defineFunction("setOverlapRecovery", _SE(js_cc_physics_BoxCharacterController_setOverlapRecovery)); + cls->defineFunction("setCenter", _SE(js_cc_physics_BoxCharacterController_setCenter)); + cls->defineFunction("getGroup", _SE(js_cc_physics_BoxCharacterController_getGroup)); + cls->defineFunction("setGroup", _SE(js_cc_physics_BoxCharacterController_setGroup)); + cls->defineFunction("getMask", _SE(js_cc_physics_BoxCharacterController_getMask)); + cls->defineFunction("setMask", _SE(js_cc_physics_BoxCharacterController_setMask)); + cls->defineFunction("updateEventListener", _SE(js_cc_physics_BoxCharacterController_updateEventListener)); + cls->defineFunction("getObjectID", _SE(js_cc_physics_BoxCharacterController_getObjectID)); + cls->defineFunction("setHalfHeight", _SE(js_cc_physics_BoxCharacterController_setHalfHeight)); + cls->defineFunction("setHalfSideExtent", _SE(js_cc_physics_BoxCharacterController_setHalfSideExtent)); + cls->defineFunction("setHalfForwardExtent", _SE(js_cc_physics_BoxCharacterController_setHalfForwardExtent)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_physics_BoxCharacterController)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_physics_BoxCharacterController_proto = cls->getProto(); + __jsb_cc_physics_BoxCharacterController_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_physics(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb.physics", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb.physics", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_physics_World(ns); + js_register_cc_physics_RigidBody(ns); + js_register_cc_physics_SphereShape(ns); + js_register_cc_physics_BoxShape(ns); + js_register_cc_physics_CapsuleShape(ns); + js_register_cc_physics_PlaneShape(ns); + js_register_cc_physics_TrimeshShape(ns); + js_register_cc_physics_CylinderShape(ns); + js_register_cc_physics_ConeShape(ns); + js_register_cc_physics_TerrainShape(ns); + js_register_cc_physics_RevoluteJoint(ns); + js_register_cc_physics_SphericalJoint(ns); + js_register_cc_physics_FixedJoint(ns); + js_register_cc_physics_GenericJoint(ns); + js_register_cc_physics_CapsuleCharacterController(ns); + js_register_cc_physics_BoxCharacterController(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_physics_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_physics_auto.h new file mode 100644 index 0000000000..049e8d5469 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_physics_auto.h @@ -0,0 +1,125 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "physics/PhysicsSDK.h" +#include "bindings/auto/jsb_scene_auto.h" + + + +bool register_all_physics(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::World); +extern se::Object *__jsb_cc_physics_World_proto; // NOLINT +extern se::Class * __jsb_cc_physics_World_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::RigidBody); +extern se::Object *__jsb_cc_physics_RigidBody_proto; // NOLINT +extern se::Class * __jsb_cc_physics_RigidBody_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::SphereShape); +extern se::Object *__jsb_cc_physics_SphereShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_SphereShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::BoxShape); +extern se::Object *__jsb_cc_physics_BoxShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_BoxShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::CapsuleShape); +extern se::Object *__jsb_cc_physics_CapsuleShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_CapsuleShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::PlaneShape); +extern se::Object *__jsb_cc_physics_PlaneShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_PlaneShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::TrimeshShape); +extern se::Object *__jsb_cc_physics_TrimeshShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_TrimeshShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::CylinderShape); +extern se::Object *__jsb_cc_physics_CylinderShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_CylinderShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::ConeShape); +extern se::Object *__jsb_cc_physics_ConeShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_ConeShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::TerrainShape); +extern se::Object *__jsb_cc_physics_TerrainShape_proto; // NOLINT +extern se::Class * __jsb_cc_physics_TerrainShape_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::RevoluteJoint); +extern se::Object *__jsb_cc_physics_RevoluteJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_RevoluteJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::SphericalJoint); +extern se::Object *__jsb_cc_physics_SphericalJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_SphericalJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::FixedJoint); +extern se::Object *__jsb_cc_physics_FixedJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_FixedJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::GenericJoint); +extern se::Object *__jsb_cc_physics_GenericJoint_proto; // NOLINT +extern se::Class * __jsb_cc_physics_GenericJoint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::CapsuleCharacterController); +extern se::Object *__jsb_cc_physics_CapsuleCharacterController_proto; // NOLINT +extern se::Class * __jsb_cc_physics_CapsuleCharacterController_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::physics::BoxCharacterController); +extern se::Object *__jsb_cc_physics_BoxCharacterController_proto; // NOLINT +extern se::Class * __jsb_cc_physics_BoxCharacterController_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_pipeline_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_pipeline_auto.cpp new file mode 100644 index 0000000000..2a13acd513 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_pipeline_auto.cpp @@ -0,0 +1,19556 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_pipeline_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "renderer/pipeline/PipelineUBO.h" + +using namespace cc; + + +#define cc_pipeline_RenderPipeline_globalDSManager_get(self_) self_->getGlobalDSManager() + + +#define cc_pipeline_RenderPipeline_descriptorSet_get(self_) self_->getDescriptorSet() + + +#define cc_pipeline_RenderPipeline_descriptorSetLayout_get(self_) self_->getDescriptorSetLayout() + + +#define cc_pipeline_RenderPipeline_constantMacros_get(self_) self_->getConstantMacros() + + +#define cc_pipeline_RenderPipeline_clusterEnabled_get(self_) self_->isClusterEnabled() +#define cc_pipeline_RenderPipeline_clusterEnabled_set(self_, val_) self_->setClusterEnabled(val_) + + +#define cc_pipeline_RenderPipeline_bloomEnabled_get(self_) self_->isBloomEnabled() +#define cc_pipeline_RenderPipeline_bloomEnabled_set(self_, val_) self_->setBloomEnabled(val_) + + +#define cc_pipeline_RenderPipeline_pipelineSceneData_get(self_) self_->getPipelineSceneData() + + +#define cc_pipeline_RenderPipeline_geometryRenderer_get(self_) self_->getGeometryRenderer() + + +#define cc_pipeline_RenderPipeline_profiler_get(self_) self_->getProfiler() +#define cc_pipeline_RenderPipeline_profiler_set(self_, val_) self_->setProfiler(val_) + + +#define cc_pipeline_RenderPipeline_shadingScale_get(self_) self_->getShadingScale() +#define cc_pipeline_RenderPipeline_shadingScale_set(self_, val_) self_->setShadingScale(val_) + + +#define cc_pipeline_RenderPipeline__tag_get(self_) self_->getTag() +#define cc_pipeline_RenderPipeline__tag_set(self_, val_) self_->setTag(val_) + + +#define cc_pipeline_RenderPipeline__flows_get(self_) self_->getFlows() +#define cc_pipeline_RenderPipeline__flows_set(self_, val_) self_->setFlows(val_) + + +#define cc_pipeline_PipelineSceneData_isHDR_get(self_) self_->isHDR() +#define cc_pipeline_PipelineSceneData_isHDR_set(self_, val_) self_->setHDR(val_) + + +#define cc_pipeline_PipelineSceneData_shadingScale_get(self_) self_->getShadingScale() +#define cc_pipeline_PipelineSceneData_shadingScale_set(self_, val_) self_->setShadingScale(val_) + + +#define cc_pipeline_PipelineSceneData_fog_get(self_) self_->getFog() + + +#define cc_pipeline_PipelineSceneData_ambient_get(self_) self_->getAmbient() + + +#define cc_pipeline_PipelineSceneData_skybox_get(self_) self_->getSkybox() + + +#define cc_pipeline_PipelineSceneData_shadows_get(self_) self_->getShadows() + + +#define cc_pipeline_PipelineSceneData_skin_get(self_) self_->getSkin() + + +#define cc_pipeline_PipelineSceneData_postSettings_get(self_) self_->getPostSettings() + + +#define cc_pipeline_PipelineSceneData_lightProbes_get(self_) self_->getLightProbes() + + +#define cc_pipeline_PipelineSceneData_validPunctualLights_get(self_) self_->getValidPunctualLights() +#define cc_pipeline_PipelineSceneData_validPunctualLights_set(self_, val_) self_->setValidPunctualLights(val_) + + +#define cc_pipeline_PipelineSceneData_csmSupported_get(self_) self_->getCSMSupported() + + +#define cc_pipeline_PipelineSceneData_standardSkinModel_get(self_) self_->getStandardSkinModel() +#define cc_pipeline_PipelineSceneData_standardSkinModel_set(self_, val_) self_->setStandardSkinModel(val_) + + +#define cc_pipeline_PipelineSceneData_skinMaterialModel_get(self_) self_->getSkinMaterialModel() +#define cc_pipeline_PipelineSceneData_skinMaterialModel_set(self_, val_) self_->setSkinMaterialModel(val_) + + +#define cc_pipeline_RenderStage__name_get(self_) self_->getName() +#define cc_pipeline_RenderStage__name_set(self_, val_) self_->setName(val_) + + +#define cc_pipeline_RenderStage__priority_get(self_) self_->getPriority() +#define cc_pipeline_RenderStage__priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_pipeline_RenderStage__tag_get(self_) self_->getTag() +#define cc_pipeline_RenderStage__tag_set(self_, val_) self_->setTag(val_) + + +#define cc_pipeline_BloomStage_threshold_get(self_) self_->getThreshold() +#define cc_pipeline_BloomStage_threshold_set(self_, val_) self_->setThreshold(val_) + + +#define cc_pipeline_BloomStage_intensity_get(self_) self_->getIntensity() +#define cc_pipeline_BloomStage_intensity_set(self_, val_) self_->setIntensity(val_) + + +#define cc_pipeline_BloomStage_iterations_get(self_) self_->getIterations() +#define cc_pipeline_BloomStage_iterations_set(self_, val_) self_->setIterations(val_) + + +#define cc_pipeline_RenderFlow__name_get(self_) self_->getName() +#define cc_pipeline_RenderFlow__name_set(self_, val_) self_->setName(val_) + + +#define cc_pipeline_RenderFlow__priority_get(self_) self_->getPriority() +#define cc_pipeline_RenderFlow__priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_pipeline_RenderFlow__tag_get(self_) self_->getTag() +#define cc_pipeline_RenderFlow__tag_set(self_, val_) self_->setTag(val_) + + +#define cc_pipeline_RenderFlow__stages_get(self_) self_->getStages() +#define cc_pipeline_RenderFlow__stages_set(self_, val_) self_->setStages(val_) + + +#define cc_pipeline_DebugView_singleMode_get(self_) self_->getSingleMode() +#define cc_pipeline_DebugView_singleMode_set(self_, val_) self_->setSingleMode(val_) + + +#define cc_pipeline_DebugView_lightingWithAlbedo_get(self_) self_->isLightingWithAlbedo() +#define cc_pipeline_DebugView_lightingWithAlbedo_set(self_, val_) self_->setLightingWithAlbedo(val_) + + +#define cc_pipeline_DebugView_csmLayerColoration_get(self_) self_->isCsmLayerColoration() +#define cc_pipeline_DebugView_csmLayerColoration_set(self_, val_) self_->setCsmLayerColoration(val_) + + + +se::Class* __jsb_cc_pipeline_SkinningJointCapacity_class = nullptr; +se::Object* __jsb_cc_pipeline_SkinningJointCapacity_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SkinningJointCapacity) + +static bool js_new_cc_pipeline_SkinningJointCapacity(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SkinningJointCapacity *result; + result = (cc::pipeline::SkinningJointCapacity *)new cc::pipeline::SkinningJointCapacity(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SkinningJointCapacity, __jsb_cc_pipeline_SkinningJointCapacity_class, js_delete_cc_pipeline_SkinningJointCapacity) + +static bool js_delete_cc_pipeline_SkinningJointCapacity(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SkinningJointCapacity) + +bool js_register_cc_pipeline_SkinningJointCapacity(se::Object* obj) { + auto* cls = se::Class::create("SkinningJointCapacity", obj, nullptr, _SE(js_new_cc_pipeline_SkinningJointCapacity)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SkinningJointCapacity)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SkinningJointCapacity_proto = cls->getProto(); + __jsb_cc_pipeline_SkinningJointCapacity_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderObject_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderObject) + +static bool js_cc_pipeline_RenderObject_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderObject_depth_set) + +static bool js_cc_pipeline_RenderObject_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderObject_depth_get) + +static bool js_cc_pipeline_RenderObject_model_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->model, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderObject_model_set) + +static bool js_cc_pipeline_RenderObject_model_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderObject *arg1 = (cc::pipeline::RenderObject *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->model, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->model, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderObject_model_get) + +static bool js_new_cc_pipeline_RenderObject(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderObject *result; + result = (cc::pipeline::RenderObject *)new cc::pipeline::RenderObject(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderObject, __jsb_cc_pipeline_RenderObject_class, js_delete_cc_pipeline_RenderObject) + +static bool js_delete_cc_pipeline_RenderObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderObject) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderObject * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + json->getProperty("model", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->model), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderObject(se::Object* obj) { + auto* cls = se::Class::create("RenderObject", obj, nullptr, _SE(js_new_cc_pipeline_RenderObject)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("depth", _SE(js_cc_pipeline_RenderObject_depth_get), _SE(js_cc_pipeline_RenderObject_depth_set)); + cls->defineProperty("model", _SE(js_cc_pipeline_RenderObject_model_get), _SE(js_cc_pipeline_RenderObject_model_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderObject_proto = cls->getProto(); + __jsb_cc_pipeline_RenderObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderTargetInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderTargetInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTargetInfo) + +static bool js_cc_pipeline_RenderTargetInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTargetInfo_width_set) + +static bool js_cc_pipeline_RenderTargetInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTargetInfo_width_get) + +static bool js_cc_pipeline_RenderTargetInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTargetInfo_height_set) + +static bool js_cc_pipeline_RenderTargetInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTargetInfo *arg1 = (cc::pipeline::RenderTargetInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTargetInfo_height_get) + +static bool js_new_cc_pipeline_RenderTargetInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderTargetInfo *result; + result = (cc::pipeline::RenderTargetInfo *)new cc::pipeline::RenderTargetInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderTargetInfo, __jsb_cc_pipeline_RenderTargetInfo_class, js_delete_cc_pipeline_RenderTargetInfo) + +static bool js_delete_cc_pipeline_RenderTargetInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTargetInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTargetInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderTargetInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderTargetInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderTargetInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_pipeline_RenderTargetInfo_width_get), _SE(js_cc_pipeline_RenderTargetInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_pipeline_RenderTargetInfo_height_get), _SE(js_cc_pipeline_RenderTargetInfo_height_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderTargetInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderTargetInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderTargetInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderPass_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPass_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPass) + +static bool js_cc_pipeline_RenderPass_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_priority_set) + +static bool js_cc_pipeline_RenderPass_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_priority_get) + +static bool js_cc_pipeline_RenderPass_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->hash, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_hash_set) + +static bool js_cc_pipeline_RenderPass_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->hash, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_hash_get) + +static bool js_cc_pipeline_RenderPass_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_depth_set) + +static bool js_cc_pipeline_RenderPass_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_depth_get) + +static bool js_cc_pipeline_RenderPass_shaderID_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shaderID, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_shaderID_set) + +static bool js_cc_pipeline_RenderPass_shaderID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shaderID, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_shaderID_get) + +static bool js_cc_pipeline_RenderPass_passIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_passIndex_set) + +static bool js_cc_pipeline_RenderPass_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_passIndex_get) + +static bool js_cc_pipeline_RenderPass_subModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subModel, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPass_subModel_set) + +static bool js_cc_pipeline_RenderPass_subModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPass *arg1 = (cc::pipeline::RenderPass *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subModel, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subModel, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPass_subModel_get) + +static bool js_new_cc_pipeline_RenderPass(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPass *result; + result = (cc::pipeline::RenderPass *)new cc::pipeline::RenderPass(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPass, __jsb_cc_pipeline_RenderPass_class, js_delete_cc_pipeline_RenderPass) + +static bool js_delete_cc_pipeline_RenderPass(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPass) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPass * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("hash", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->hash), ctx); + } + + + json->getProperty("depth", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depth), ctx); + } + + + json->getProperty("shaderID", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shaderID), ctx); + } + + + json->getProperty("passIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passIndex), ctx); + } + + + json->getProperty("subModel", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subModel), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderPass(se::Object* obj) { + auto* cls = se::Class::create("RenderPass", obj, nullptr, _SE(js_new_cc_pipeline_RenderPass)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("priority", _SE(js_cc_pipeline_RenderPass_priority_get), _SE(js_cc_pipeline_RenderPass_priority_set)); + cls->defineProperty("hash", _SE(js_cc_pipeline_RenderPass_hash_get), _SE(js_cc_pipeline_RenderPass_hash_set)); + cls->defineProperty("depth", _SE(js_cc_pipeline_RenderPass_depth_get), _SE(js_cc_pipeline_RenderPass_depth_set)); + cls->defineProperty("shaderID", _SE(js_cc_pipeline_RenderPass_shaderID_get), _SE(js_cc_pipeline_RenderPass_shaderID_set)); + cls->defineProperty("passIndex", _SE(js_cc_pipeline_RenderPass_passIndex_get), _SE(js_cc_pipeline_RenderPass_passIndex_set)); + cls->defineProperty("subModel", _SE(js_cc_pipeline_RenderPass_subModel_get), _SE(js_cc_pipeline_RenderPass_subModel_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPass)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPass_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPass_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderPassDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPassDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPassDesc) + +static bool js_cc_pipeline_RenderPassDesc_index_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->index, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPassDesc_index_set) + +static bool js_cc_pipeline_RenderPassDesc_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->index, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPassDesc_index_get) + +static bool js_cc_pipeline_RenderPassDesc_colorAttachments_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorAttachments, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPassDesc_colorAttachments_set) + +static bool js_cc_pipeline_RenderPassDesc_colorAttachments_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorAttachments, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorAttachments, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPassDesc_colorAttachments_get) + +static bool js_cc_pipeline_RenderPassDesc_depthStencilAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilAttachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_set) + +static bool js_cc_pipeline_RenderPassDesc_depthStencilAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPassDesc *arg1 = (cc::pipeline::RenderPassDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilAttachment, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilAttachment, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_get) + +static bool js_new_cc_pipeline_RenderPassDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPassDesc *result; + result = (cc::pipeline::RenderPassDesc *)new cc::pipeline::RenderPassDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPassDesc, __jsb_cc_pipeline_RenderPassDesc_class, js_delete_cc_pipeline_RenderPassDesc) + +static bool js_delete_cc_pipeline_RenderPassDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPassDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPassDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("index", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->index), ctx); + } + + + json->getProperty("colorAttachments", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorAttachments), ctx); + } + + + json->getProperty("depthStencilAttachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilAttachment), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderPassDesc(se::Object* obj) { + auto* cls = se::Class::create("RenderPassDesc", obj, nullptr, _SE(js_new_cc_pipeline_RenderPassDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("index", _SE(js_cc_pipeline_RenderPassDesc_index_get), _SE(js_cc_pipeline_RenderPassDesc_index_set)); + cls->defineProperty("colorAttachments", _SE(js_cc_pipeline_RenderPassDesc_colorAttachments_get), _SE(js_cc_pipeline_RenderPassDesc_colorAttachments_set)); + cls->defineProperty("depthStencilAttachment", _SE(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_get), _SE(js_cc_pipeline_RenderPassDesc_depthStencilAttachment_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPassDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPassDesc_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPassDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderTextureDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderTextureDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTextureDesc) + +static bool js_cc_pipeline_RenderTextureDesc_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_name_set) + +static bool js_cc_pipeline_RenderTextureDesc_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_name_get) + +static bool js_cc_pipeline_RenderTextureDesc_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_type_set) + +static bool js_cc_pipeline_RenderTextureDesc_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_type_get) + +static bool js_cc_pipeline_RenderTextureDesc_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_usage_set) + +static bool js_cc_pipeline_RenderTextureDesc_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_usage_get) + +static bool js_cc_pipeline_RenderTextureDesc_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_format_set) + +static bool js_cc_pipeline_RenderTextureDesc_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_format_get) + +static bool js_cc_pipeline_RenderTextureDesc_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_width_set) + +static bool js_cc_pipeline_RenderTextureDesc_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_width_get) + +static bool js_cc_pipeline_RenderTextureDesc_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderTextureDesc_height_set) + +static bool js_cc_pipeline_RenderTextureDesc_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderTextureDesc *arg1 = (cc::pipeline::RenderTextureDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderTextureDesc_height_get) + +static bool js_new_cc_pipeline_RenderTextureDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderTextureDesc *result; + result = (cc::pipeline::RenderTextureDesc *)new cc::pipeline::RenderTextureDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderTextureDesc, __jsb_cc_pipeline_RenderTextureDesc_class, js_delete_cc_pipeline_RenderTextureDesc) + +static bool js_delete_cc_pipeline_RenderTextureDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderTextureDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTextureDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + json->getProperty("format", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->format), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderTextureDesc(se::Object* obj) { + auto* cls = se::Class::create("RenderTextureDesc", obj, nullptr, _SE(js_new_cc_pipeline_RenderTextureDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_RenderTextureDesc_name_get), _SE(js_cc_pipeline_RenderTextureDesc_name_set)); + cls->defineProperty("type", _SE(js_cc_pipeline_RenderTextureDesc_type_get), _SE(js_cc_pipeline_RenderTextureDesc_type_set)); + cls->defineProperty("usage", _SE(js_cc_pipeline_RenderTextureDesc_usage_get), _SE(js_cc_pipeline_RenderTextureDesc_usage_set)); + cls->defineProperty("format", _SE(js_cc_pipeline_RenderTextureDesc_format_get), _SE(js_cc_pipeline_RenderTextureDesc_format_set)); + cls->defineProperty("width", _SE(js_cc_pipeline_RenderTextureDesc_width_get), _SE(js_cc_pipeline_RenderTextureDesc_width_set)); + cls->defineProperty("height", _SE(js_cc_pipeline_RenderTextureDesc_height_get), _SE(js_cc_pipeline_RenderTextureDesc_height_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderTextureDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderTextureDesc_proto = cls->getProto(); + __jsb_cc_pipeline_RenderTextureDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_FrameBufferDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_FrameBufferDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_FrameBufferDesc) + +static bool js_cc_pipeline_FrameBufferDesc_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_name_set) + +static bool js_cc_pipeline_FrameBufferDesc_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_name_get) + +static bool js_cc_pipeline_FrameBufferDesc_renderPass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_renderPass_set) + +static bool js_cc_pipeline_FrameBufferDesc_renderPass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPass, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_renderPass_get) + +static bool js_cc_pipeline_FrameBufferDesc_colorTextures_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->colorTextures, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_colorTextures_set) + +static bool js_cc_pipeline_FrameBufferDesc_colorTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->colorTextures, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->colorTextures, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_colorTextures_get) + +static bool js_cc_pipeline_FrameBufferDesc_depthStencilTexture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->depthStencilTexture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_set) + +static bool js_cc_pipeline_FrameBufferDesc_depthStencilTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::FrameBufferDesc *arg1 = (cc::pipeline::FrameBufferDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->depthStencilTexture, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->depthStencilTexture, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_get) + +static bool js_new_cc_pipeline_FrameBufferDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::FrameBufferDesc *result; + result = (cc::pipeline::FrameBufferDesc *)new cc::pipeline::FrameBufferDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_FrameBufferDesc, __jsb_cc_pipeline_FrameBufferDesc_class, js_delete_cc_pipeline_FrameBufferDesc) + +static bool js_delete_cc_pipeline_FrameBufferDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_FrameBufferDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::FrameBufferDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("renderPass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPass), ctx); + } + + + json->getProperty("colorTextures", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->colorTextures), ctx); + } + + + json->getProperty("depthStencilTexture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->depthStencilTexture), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_FrameBufferDesc(se::Object* obj) { + auto* cls = se::Class::create("FrameBufferDesc", obj, nullptr, _SE(js_new_cc_pipeline_FrameBufferDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_FrameBufferDesc_name_get), _SE(js_cc_pipeline_FrameBufferDesc_name_set)); + cls->defineProperty("renderPass", _SE(js_cc_pipeline_FrameBufferDesc_renderPass_get), _SE(js_cc_pipeline_FrameBufferDesc_renderPass_set)); + cls->defineProperty("colorTextures", _SE(js_cc_pipeline_FrameBufferDesc_colorTextures_get), _SE(js_cc_pipeline_FrameBufferDesc_colorTextures_set)); + cls->defineProperty("depthStencilTexture", _SE(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_get), _SE(js_cc_pipeline_FrameBufferDesc_depthStencilTexture_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_FrameBufferDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_FrameBufferDesc_proto = cls->getProto(); + __jsb_cc_pipeline_FrameBufferDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderFlowType arg1 ; + std::underlying_type_t< cc::pipeline::RenderFlowType > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPassStage arg1 ; + std::underlying_type_t< cc::pipeline::RenderPassStage > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_InternalBindingDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_InternalBindingDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingDesc) + +static bool js_cc_pipeline_InternalBindingDesc_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_type_set) + +static bool js_cc_pipeline_InternalBindingDesc_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_type_get) + +static bool js_cc_pipeline_InternalBindingDesc_blockInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blockInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_blockInfo_set) + +static bool js_cc_pipeline_InternalBindingDesc_blockInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blockInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blockInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_blockInfo_get) + +static bool js_cc_pipeline_InternalBindingDesc_samplerInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplerInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_samplerInfo_set) + +static bool js_cc_pipeline_InternalBindingDesc_samplerInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplerInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplerInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_samplerInfo_get) + +static bool js_cc_pipeline_InternalBindingDesc_defaultValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defaultValue, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingDesc_defaultValue_set) + +static bool js_cc_pipeline_InternalBindingDesc_defaultValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingDesc *arg1 = (cc::pipeline::InternalBindingDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defaultValue, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defaultValue, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingDesc_defaultValue_get) + +static bool js_new_cc_pipeline_InternalBindingDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::InternalBindingDesc *result; + result = (cc::pipeline::InternalBindingDesc *)new cc::pipeline::InternalBindingDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InternalBindingDesc, __jsb_cc_pipeline_InternalBindingDesc_class, js_delete_cc_pipeline_InternalBindingDesc) + +static bool js_delete_cc_pipeline_InternalBindingDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingDesc) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingDesc * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("blockInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blockInfo), ctx); + } + + + json->getProperty("samplerInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplerInfo), ctx); + } + + + json->getProperty("defaultValue", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defaultValue), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_InternalBindingDesc(se::Object* obj) { + auto* cls = se::Class::create("InternalBindingDesc", obj, nullptr, _SE(js_new_cc_pipeline_InternalBindingDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_pipeline_InternalBindingDesc_type_get), _SE(js_cc_pipeline_InternalBindingDesc_type_set)); + cls->defineProperty("blockInfo", _SE(js_cc_pipeline_InternalBindingDesc_blockInfo_get), _SE(js_cc_pipeline_InternalBindingDesc_blockInfo_set)); + cls->defineProperty("samplerInfo", _SE(js_cc_pipeline_InternalBindingDesc_samplerInfo_get), _SE(js_cc_pipeline_InternalBindingDesc_samplerInfo_set)); + cls->defineProperty("defaultValue", _SE(js_cc_pipeline_InternalBindingDesc_defaultValue_get), _SE(js_cc_pipeline_InternalBindingDesc_defaultValue_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InternalBindingDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InternalBindingDesc_proto = cls->getProto(); + __jsb_cc_pipeline_InternalBindingDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_InternalBindingInst_class = nullptr; +se::Object* __jsb_cc_pipeline_InternalBindingInst_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingInst) + +static bool js_cc_pipeline_InternalBindingInst_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingInst_buffer_set) + +static bool js_cc_pipeline_InternalBindingInst_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingInst_buffer_get) + +static bool js_cc_pipeline_InternalBindingInst_sampler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sampler, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingInst_sampler_set) + +static bool js_cc_pipeline_InternalBindingInst_sampler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sampler, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sampler, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingInst_sampler_get) + +static bool js_cc_pipeline_InternalBindingInst_texture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texture, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InternalBindingInst_texture_set) + +static bool js_cc_pipeline_InternalBindingInst_texture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InternalBindingInst *arg1 = (cc::pipeline::InternalBindingInst *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texture, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texture, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InternalBindingInst_texture_get) + +static bool js_new_cc_pipeline_InternalBindingInst(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::InternalBindingInst *result; + result = (cc::pipeline::InternalBindingInst *)new cc::pipeline::InternalBindingInst(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InternalBindingInst, __jsb_cc_pipeline_InternalBindingInst_class, js_delete_cc_pipeline_InternalBindingInst) + +static bool js_delete_cc_pipeline_InternalBindingInst(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InternalBindingInst) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingInst * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + json->getProperty("sampler", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sampler), ctx); + } + + + json->getProperty("texture", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->texture), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_InternalBindingInst(se::Object* obj) { + auto* cls = se::Class::create("InternalBindingInst", obj, __jsb_cc_pipeline_InternalBindingDesc_proto, _SE(js_new_cc_pipeline_InternalBindingInst)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffer", _SE(js_cc_pipeline_InternalBindingInst_buffer_get), _SE(js_cc_pipeline_InternalBindingInst_buffer_set)); + cls->defineProperty("sampler", _SE(js_cc_pipeline_InternalBindingInst_sampler_get), _SE(js_cc_pipeline_InternalBindingInst_sampler_set)); + cls->defineProperty("texture", _SE(js_cc_pipeline_InternalBindingInst_texture_get), _SE(js_cc_pipeline_InternalBindingInst_texture_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InternalBindingInst)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InternalBindingInst_proto = cls->getProto(); + __jsb_cc_pipeline_InternalBindingInst_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderQueueCreateInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderQueueCreateInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueCreateInfo) + +static bool js_cc_pipeline_RenderQueueCreateInfo_isTransparent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isTransparent); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_set) + +static bool js_cc_pipeline_RenderQueueCreateInfo_isTransparent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isTransparent, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_get) + +static bool js_cc_pipeline_RenderQueueCreateInfo_phases_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->phases, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueCreateInfo_phases_set) + +static bool js_cc_pipeline_RenderQueueCreateInfo_phases_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->phases, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueCreateInfo_phases_get) + +static bool js_cc_pipeline_RenderQueueCreateInfo_sortFunc_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sortFunc, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_set) + +static bool js_cc_pipeline_RenderQueueCreateInfo_sortFunc_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueCreateInfo *arg1 = (cc::pipeline::RenderQueueCreateInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sortFunc, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sortFunc, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_get) + +static bool js_new_cc_pipeline_RenderQueueCreateInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderQueueCreateInfo *result; + result = (cc::pipeline::RenderQueueCreateInfo *)new cc::pipeline::RenderQueueCreateInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderQueueCreateInfo, __jsb_cc_pipeline_RenderQueueCreateInfo_class, js_delete_cc_pipeline_RenderQueueCreateInfo) + +static bool js_delete_cc_pipeline_RenderQueueCreateInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueCreateInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderQueueCreateInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("isTransparent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isTransparent), ctx); + } + + + json->getProperty("phases", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->phases), ctx); + } + + + json->getProperty("sortFunc", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->sortFunc), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderQueueCreateInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderQueueCreateInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderQueueCreateInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isTransparent", _SE(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_get), _SE(js_cc_pipeline_RenderQueueCreateInfo_isTransparent_set)); + cls->defineProperty("phases", _SE(js_cc_pipeline_RenderQueueCreateInfo_phases_get), _SE(js_cc_pipeline_RenderQueueCreateInfo_phases_set)); + cls->defineProperty("sortFunc", _SE(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_get), _SE(js_cc_pipeline_RenderQueueCreateInfo_sortFunc_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderQueueCreateInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderQueueCreateInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderQueueCreateInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPriority arg1 ; + std::underlying_type_t< cc::pipeline::RenderPriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderQueueSortMode arg1 ; + std::underlying_type_t< cc::pipeline::RenderQueueSortMode > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_RenderQueueDesc_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderQueueDesc_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueDesc) + +static bool js_new_cc_pipeline_RenderQueueDesc__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *result; + result = (cc::pipeline::RenderQueueDesc *)new cc::pipeline::RenderQueueDesc(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_pipeline_RenderQueueDesc__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + bool arg1 ; + cc::pipeline::RenderQueueSortMode arg2 ; + ccstd::vector< ccstd::string > *arg3 = 0 ; + ccstd::vector< ccstd::string > temp3 ; + cc::pipeline::RenderQueueDesc *result; + + ok &= sevalue_to_native(args[0], &arg1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::pipeline::RenderQueueDesc *)new cc::pipeline::RenderQueueDesc(arg1,arg2,(ccstd::vector< ccstd::string > const &)*arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_pipeline_RenderQueueDesc(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_pipeline_RenderQueueDesc__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_pipeline_RenderQueueDesc__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of RenderQueueDesc"); + return false; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderQueueDesc, __jsb_cc_pipeline_RenderQueueDesc_class, js_delete_cc_pipeline_RenderQueueDesc) + +static bool js_cc_pipeline_RenderQueueDesc_isTransparent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isTransparent); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueDesc_isTransparent_set) + +static bool js_cc_pipeline_RenderQueueDesc_isTransparent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isTransparent, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueDesc_isTransparent_get) + +static bool js_cc_pipeline_RenderQueueDesc_sortMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->sortMode, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueDesc_sortMode_set) + +static bool js_cc_pipeline_RenderQueueDesc_sortMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->sortMode, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->sortMode, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueDesc_sortMode_get) + +static bool js_cc_pipeline_RenderQueueDesc_stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderQueueDesc_stages_set) + +static bool js_cc_pipeline_RenderQueueDesc_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderQueueDesc *arg1 = (cc::pipeline::RenderQueueDesc *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderQueueDesc_stages_get) + +static bool js_delete_cc_pipeline_RenderQueueDesc(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderQueueDesc) + +bool js_register_cc_pipeline_RenderQueueDesc(se::Object* obj) { + auto* cls = se::Class::create("RenderQueueDesc", obj, nullptr, _SE(js_new_cc_pipeline_RenderQueueDesc)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isTransparent", _SE(js_cc_pipeline_RenderQueueDesc_isTransparent_get), _SE(js_cc_pipeline_RenderQueueDesc_isTransparent_set)); + cls->defineProperty("sortMode", _SE(js_cc_pipeline_RenderQueueDesc_sortMode_get), _SE(js_cc_pipeline_RenderQueueDesc_sortMode_set)); + cls->defineProperty("stages", _SE(js_cc_pipeline_RenderQueueDesc_stages_get), _SE(js_cc_pipeline_RenderQueueDesc_stages_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderQueueDesc)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderQueueDesc_proto = cls->getProto(); + __jsb_cc_pipeline_RenderQueueDesc_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_getPhaseID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::pipeline::getPhaseID((ccstd::string const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_getPhaseID) + +static bool js_cc_pipeline_opaqueCompareFn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = 0 ; + cc::pipeline::RenderPass *arg2 = 0 ; + cc::pipeline::RenderPass temp1 ; + cc::pipeline::RenderPass temp2 ; + bool result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)cc::pipeline::opaqueCompareFn((cc::pipeline::RenderPass const &)*arg1,(cc::pipeline::RenderPass const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_opaqueCompareFn) + +static bool js_cc_pipeline_transparentCompareFn(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPass *arg1 = 0 ; + cc::pipeline::RenderPass *arg2 = 0 ; + cc::pipeline::RenderPass temp1 ; + cc::pipeline::RenderPass temp2 ; + bool result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)cc::pipeline::transparentCompareFn((cc::pipeline::RenderPass const &)*arg1,(cc::pipeline::RenderPass const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_transparentCompareFn) + +static bool js_cc_pipeline_convertPhase(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< ccstd::string > *arg1 = 0 ; + ccstd::vector< ccstd::string > temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::pipeline::convertPhase((ccstd::vector< ccstd::string > const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_convertPhase) + +static bool js_cc_pipeline_toNumber__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::PipelineGlobalBindings arg1 ; + std::underlying_type_t< cc::pipeline::PipelineGlobalBindings > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ModelLocalBindings arg1 ; + std::underlying_type_t< cc::pipeline::ModelLocalBindings > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::SetIndex arg1 ; + std::underlying_type_t< cc::pipeline::SetIndex > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_UBOLocalBatched_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOLocalBatched_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocalBatched) + +static bool js_new_cc_pipeline_UBOLocalBatched(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOLocalBatched *result; + result = (cc::pipeline::UBOLocalBatched *)new cc::pipeline::UBOLocalBatched(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOLocalBatched, __jsb_cc_pipeline_UBOLocalBatched_class, js_delete_cc_pipeline_UBOLocalBatched) + +static bool js_delete_cc_pipeline_UBOLocalBatched(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocalBatched) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocalBatched * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOLocalBatched(se::Object* obj) { + auto* cls = se::Class::create("UBOLocalBatched", obj, nullptr, _SE(js_new_cc_pipeline_UBOLocalBatched)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOLocalBatched)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOLocalBatched_proto = cls->getProto(); + __jsb_cc_pipeline_UBOLocalBatched_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOLocal_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOLocal_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocal) + +static bool js_new_cc_pipeline_UBOLocal(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOLocal *result; + result = (cc::pipeline::UBOLocal *)new cc::pipeline::UBOLocal(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOLocal, __jsb_cc_pipeline_UBOLocal_class, js_delete_cc_pipeline_UBOLocal) + +static bool js_delete_cc_pipeline_UBOLocal(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOLocal) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocal * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOLocal(se::Object* obj) { + auto* cls = se::Class::create("UBOLocal", obj, nullptr, _SE(js_new_cc_pipeline_UBOLocal)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOLocal)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOLocal_proto = cls->getProto(); + __jsb_cc_pipeline_UBOLocal_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOWorldBound_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOWorldBound_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOWorldBound) + +static bool js_new_cc_pipeline_UBOWorldBound(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOWorldBound *result; + result = (cc::pipeline::UBOWorldBound *)new cc::pipeline::UBOWorldBound(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOWorldBound, __jsb_cc_pipeline_UBOWorldBound_class, js_delete_cc_pipeline_UBOWorldBound) + +static bool js_delete_cc_pipeline_UBOWorldBound(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOWorldBound) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOWorldBound * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOWorldBound(se::Object* obj) { + auto* cls = se::Class::create("UBOWorldBound", obj, nullptr, _SE(js_new_cc_pipeline_UBOWorldBound)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOWorldBound)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOWorldBound_proto = cls->getProto(); + __jsb_cc_pipeline_UBOWorldBound_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOForwardLight_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOForwardLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOForwardLight) + +static bool js_new_cc_pipeline_UBOForwardLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOForwardLight *result; + result = (cc::pipeline::UBOForwardLight *)new cc::pipeline::UBOForwardLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOForwardLight, __jsb_cc_pipeline_UBOForwardLight_class, js_delete_cc_pipeline_UBOForwardLight) + +static bool js_delete_cc_pipeline_UBOForwardLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOForwardLight) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOForwardLight * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOForwardLight(se::Object* obj) { + auto* cls = se::Class::create("UBOForwardLight", obj, nullptr, _SE(js_new_cc_pipeline_UBOForwardLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOForwardLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOForwardLight_proto = cls->getProto(); + __jsb_cc_pipeline_UBOForwardLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBODeferredLight_class = nullptr; +se::Object* __jsb_cc_pipeline_UBODeferredLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBODeferredLight) + +static bool js_new_cc_pipeline_UBODeferredLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBODeferredLight *result; + result = (cc::pipeline::UBODeferredLight *)new cc::pipeline::UBODeferredLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBODeferredLight, __jsb_cc_pipeline_UBODeferredLight_class, js_delete_cc_pipeline_UBODeferredLight) + +static bool js_delete_cc_pipeline_UBODeferredLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBODeferredLight) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBODeferredLight * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBODeferredLight(se::Object* obj) { + auto* cls = se::Class::create("UBODeferredLight", obj, nullptr, _SE(js_new_cc_pipeline_UBODeferredLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBODeferredLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBODeferredLight_proto = cls->getProto(); + __jsb_cc_pipeline_UBODeferredLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSkinningTexture_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSkinningTexture_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningTexture) + +static bool js_new_cc_pipeline_UBOSkinningTexture(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSkinningTexture *result; + result = (cc::pipeline::UBOSkinningTexture *)new cc::pipeline::UBOSkinningTexture(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSkinningTexture, __jsb_cc_pipeline_UBOSkinningTexture_class, js_delete_cc_pipeline_UBOSkinningTexture) + +static bool js_delete_cc_pipeline_UBOSkinningTexture(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningTexture) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningTexture * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSkinningTexture(se::Object* obj) { + auto* cls = se::Class::create("UBOSkinningTexture", obj, nullptr, _SE(js_new_cc_pipeline_UBOSkinningTexture)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSkinningTexture)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSkinningTexture_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSkinningTexture_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSkinningAnimation_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSkinningAnimation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningAnimation) + +static bool js_new_cc_pipeline_UBOSkinningAnimation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSkinningAnimation *result; + result = (cc::pipeline::UBOSkinningAnimation *)new cc::pipeline::UBOSkinningAnimation(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSkinningAnimation, __jsb_cc_pipeline_UBOSkinningAnimation_class, js_delete_cc_pipeline_UBOSkinningAnimation) + +static bool js_delete_cc_pipeline_UBOSkinningAnimation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinningAnimation) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningAnimation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSkinningAnimation(se::Object* obj) { + auto* cls = se::Class::create("UBOSkinningAnimation", obj, nullptr, _SE(js_new_cc_pipeline_UBOSkinningAnimation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSkinningAnimation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSkinningAnimation_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSkinningAnimation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSkinning_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSkinning_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinning) + +static bool js_cc_pipeline_UBOSkinning_initLayout_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint arg1 ; + + 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::pipeline::UBOSkinning::initLayout(SWIG_STD_MOVE(arg1)); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_UBOSkinning_initLayout_static) + +static bool js_new_cc_pipeline_UBOSkinning(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSkinning *result; + result = (cc::pipeline::UBOSkinning *)new cc::pipeline::UBOSkinning(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSkinning, __jsb_cc_pipeline_UBOSkinning_class, js_delete_cc_pipeline_UBOSkinning) + +static bool js_delete_cc_pipeline_UBOSkinning(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSkinning) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinning * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSkinning(se::Object* obj) { + auto* cls = se::Class::create("UBOSkinning", obj, nullptr, _SE(js_new_cc_pipeline_UBOSkinning)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("initLayout", _SE(js_cc_pipeline_UBOSkinning_initLayout_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSkinning)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSkinning_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSkinning_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOMorph_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOMorph_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOMorph) + +static bool js_new_cc_pipeline_UBOMorph(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOMorph *result; + result = (cc::pipeline::UBOMorph *)new cc::pipeline::UBOMorph(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOMorph, __jsb_cc_pipeline_UBOMorph_class, js_delete_cc_pipeline_UBOMorph) + +static bool js_delete_cc_pipeline_UBOMorph(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOMorph) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOMorph * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOMorph(se::Object* obj) { + auto* cls = se::Class::create("UBOMorph", obj, nullptr, _SE(js_new_cc_pipeline_UBOMorph)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOMorph)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOMorph_proto = cls->getProto(); + __jsb_cc_pipeline_UBOMorph_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOUILocal_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOUILocal_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOUILocal) + +static bool js_new_cc_pipeline_UBOUILocal(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOUILocal *result; + result = (cc::pipeline::UBOUILocal *)new cc::pipeline::UBOUILocal(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOUILocal, __jsb_cc_pipeline_UBOUILocal_class, js_delete_cc_pipeline_UBOUILocal) + +static bool js_delete_cc_pipeline_UBOUILocal(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOUILocal) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOUILocal * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOUILocal(se::Object* obj) { + auto* cls = se::Class::create("UBOUILocal", obj, nullptr, _SE(js_new_cc_pipeline_UBOUILocal)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOUILocal)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOUILocal_proto = cls->getProto(); + __jsb_cc_pipeline_UBOUILocal_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOSH_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOSH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSH) + +static bool js_new_cc_pipeline_UBOSH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOSH *result; + result = (cc::pipeline::UBOSH *)new cc::pipeline::UBOSH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOSH, __jsb_cc_pipeline_UBOSH_class, js_delete_cc_pipeline_UBOSH) + +static bool js_delete_cc_pipeline_UBOSH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOSH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOSH(se::Object* obj) { + auto* cls = se::Class::create("UBOSH", obj, nullptr, _SE(js_new_cc_pipeline_UBOSH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOSH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOSH_proto = cls->getProto(); + __jsb_cc_pipeline_UBOSH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ForwardStagePriority arg1 ; + std::underlying_type_t< cc::pipeline::ForwardStagePriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_8(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ForwardFlowPriority arg1 ; + std::underlying_type_t< cc::pipeline::ForwardFlowPriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_9(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderFlowTag arg1 ; + std::underlying_type_t< cc::pipeline::RenderFlowTag > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_10(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::DeferredStagePriority arg1 ; + std::underlying_type_t< cc::pipeline::DeferredStagePriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber__SWIG_11(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::DeferredFlowPriority arg1 ; + std::underlying_type_t< cc::pipeline::DeferredFlowPriority > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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::Class* __jsb_cc_pipeline_UBOGlobal_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOGlobal_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOGlobal) + +static bool js_new_cc_pipeline_UBOGlobal(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOGlobal *result; + result = (cc::pipeline::UBOGlobal *)new cc::pipeline::UBOGlobal(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOGlobal, __jsb_cc_pipeline_UBOGlobal_class, js_delete_cc_pipeline_UBOGlobal) + +static bool js_delete_cc_pipeline_UBOGlobal(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOGlobal) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOGlobal * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOGlobal(se::Object* obj) { + auto* cls = se::Class::create("UBOGlobal", obj, nullptr, _SE(js_new_cc_pipeline_UBOGlobal)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOGlobal)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOGlobal_proto = cls->getProto(); + __jsb_cc_pipeline_UBOGlobal_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOCamera_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOCamera_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCamera) + +static bool js_new_cc_pipeline_UBOCamera(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOCamera *result; + result = (cc::pipeline::UBOCamera *)new cc::pipeline::UBOCamera(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOCamera, __jsb_cc_pipeline_UBOCamera_class, js_delete_cc_pipeline_UBOCamera) + +static bool js_delete_cc_pipeline_UBOCamera(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCamera) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCamera * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOCamera(se::Object* obj) { + auto* cls = se::Class::create("UBOCamera", obj, nullptr, _SE(js_new_cc_pipeline_UBOCamera)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOCamera)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOCamera_proto = cls->getProto(); + __jsb_cc_pipeline_UBOCamera_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOShadow_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOShadow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOShadow) + +static bool js_new_cc_pipeline_UBOShadow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOShadow *result; + result = (cc::pipeline::UBOShadow *)new cc::pipeline::UBOShadow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOShadow, __jsb_cc_pipeline_UBOShadow_class, js_delete_cc_pipeline_UBOShadow) + +static bool js_delete_cc_pipeline_UBOShadow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOShadow) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOShadow * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOShadow(se::Object* obj) { + auto* cls = se::Class::create("UBOShadow", obj, nullptr, _SE(js_new_cc_pipeline_UBOShadow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOShadow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOShadow_proto = cls->getProto(); + __jsb_cc_pipeline_UBOShadow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_UBOCSM_class = nullptr; +se::Object* __jsb_cc_pipeline_UBOCSM_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCSM) + +static bool js_new_cc_pipeline_UBOCSM(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::UBOCSM *result; + result = (cc::pipeline::UBOCSM *)new cc::pipeline::UBOCSM(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_UBOCSM, __jsb_cc_pipeline_UBOCSM_class, js_delete_cc_pipeline_UBOCSM) + +static bool js_delete_cc_pipeline_UBOCSM(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_UBOCSM) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCSM * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_UBOCSM(se::Object* obj) { + auto* cls = se::Class::create("UBOCSM", obj, nullptr, _SE(js_new_cc_pipeline_UBOCSM)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_UBOCSM)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_UBOCSM_proto = cls->getProto(); + __jsb_cc_pipeline_UBOCSM_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DescriptorSetLayoutInfos_class = nullptr; +se::Object* __jsb_cc_pipeline_DescriptorSetLayoutInfos_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DescriptorSetLayoutInfos) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_bindings_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->bindings, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_bindings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->bindings, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->bindings, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_get) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_blocks_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->blocks, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_blocks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->blocks, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->blocks, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_get) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_samplers_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->samplers, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_samplers_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->samplers, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->samplers, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_get) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->storeImages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_set) + +static bool js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DescriptorSetLayoutInfos *arg1 = (cc::pipeline::DescriptorSetLayoutInfos *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->storeImages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->storeImages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_get) + +static bool js_new_cc_pipeline_DescriptorSetLayoutInfos(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DescriptorSetLayoutInfos *result; + result = (cc::pipeline::DescriptorSetLayoutInfos *)new cc::pipeline::DescriptorSetLayoutInfos(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DescriptorSetLayoutInfos, __jsb_cc_pipeline_DescriptorSetLayoutInfos_class, js_delete_cc_pipeline_DescriptorSetLayoutInfos) + +static bool js_delete_cc_pipeline_DescriptorSetLayoutInfos(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DescriptorSetLayoutInfos) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DescriptorSetLayoutInfos * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("bindings", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->bindings), ctx); + } + + + json->getProperty("blocks", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->blocks), ctx); + } + + + json->getProperty("samplers", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->samplers), ctx); + } + + + json->getProperty("storeImages", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->storeImages), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_DescriptorSetLayoutInfos(se::Object* obj) { + auto* cls = se::Class::create("DescriptorSetLayoutInfos", obj, nullptr, _SE(js_new_cc_pipeline_DescriptorSetLayoutInfos)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bindings", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_bindings_set)); + cls->defineProperty("blocks", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_blocks_set)); + cls->defineProperty("samplers", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_samplers_set)); + cls->defineProperty("storeImages", _SE(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_get), _SE(js_cc_pipeline_DescriptorSetLayoutInfos_storeImages_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DescriptorSetLayoutInfos)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DescriptorSetLayoutInfos_proto = cls->getProto(); + __jsb_cc_pipeline_DescriptorSetLayoutInfos_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_toNumber__SWIG_12(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::LayerList arg1 ; + std::underlying_type_t< cc::pipeline::LayerList > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::toNumber(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; +} + +static bool js_cc_pipeline_toNumber(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_7(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_8(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_9(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_10(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_11(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_pipeline_toNumber__SWIG_12(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_toNumber) + +static bool js_cc_pipeline_nextPow2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::pipeline::nextPow2(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_nextPow2) + +static bool js_cc_pipeline_supportsR16HalfFloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsR16HalfFloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsR16HalfFloatTexture) + +static bool js_cc_pipeline_supportsRGBA16HalfFloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsRGBA16HalfFloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsRGBA16HalfFloatTexture) + +static bool js_cc_pipeline_supportsR32FloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsR32FloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsR32FloatTexture) + +static bool js_cc_pipeline_supportsRGBA32FloatTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)cc::pipeline::supportsRGBA32FloatTexture((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_supportsRGBA32FloatTexture) + +se::Class* __jsb_cc_pipeline_SHADOWMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_SHADOWMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SHADOWMAP) + +static bool js_new_cc_pipeline_SHADOWMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SHADOWMAP *result; + result = (cc::pipeline::SHADOWMAP *)new cc::pipeline::SHADOWMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SHADOWMAP, __jsb_cc_pipeline_SHADOWMAP_class, js_delete_cc_pipeline_SHADOWMAP) + +static bool js_delete_cc_pipeline_SHADOWMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SHADOWMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SHADOWMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_SHADOWMAP(se::Object* obj) { + auto* cls = se::Class::create("SHADOWMAP", obj, nullptr, _SE(js_new_cc_pipeline_SHADOWMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SHADOWMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SHADOWMAP_proto = cls->getProto(); + __jsb_cc_pipeline_SHADOWMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ENVIRONMENT_class = nullptr; +se::Object* __jsb_cc_pipeline_ENVIRONMENT_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ENVIRONMENT) + +static bool js_new_cc_pipeline_ENVIRONMENT(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ENVIRONMENT *result; + result = (cc::pipeline::ENVIRONMENT *)new cc::pipeline::ENVIRONMENT(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ENVIRONMENT, __jsb_cc_pipeline_ENVIRONMENT_class, js_delete_cc_pipeline_ENVIRONMENT) + +static bool js_delete_cc_pipeline_ENVIRONMENT(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ENVIRONMENT) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::ENVIRONMENT * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_ENVIRONMENT(se::Object* obj) { + auto* cls = se::Class::create("ENVIRONMENT", obj, nullptr, _SE(js_new_cc_pipeline_ENVIRONMENT)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ENVIRONMENT)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ENVIRONMENT_proto = cls->getProto(); + __jsb_cc_pipeline_ENVIRONMENT_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_SPOTSHADOWMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_SPOTSHADOWMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SPOTSHADOWMAP) + +static bool js_new_cc_pipeline_SPOTSHADOWMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SPOTSHADOWMAP *result; + result = (cc::pipeline::SPOTSHADOWMAP *)new cc::pipeline::SPOTSHADOWMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SPOTSHADOWMAP, __jsb_cc_pipeline_SPOTSHADOWMAP_class, js_delete_cc_pipeline_SPOTSHADOWMAP) + +static bool js_delete_cc_pipeline_SPOTSHADOWMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SPOTSHADOWMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPOTSHADOWMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_SPOTSHADOWMAP(se::Object* obj) { + auto* cls = se::Class::create("SPOTSHADOWMAP", obj, nullptr, _SE(js_new_cc_pipeline_SPOTSHADOWMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SPOTSHADOWMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SPOTSHADOWMAP_proto = cls->getProto(); + __jsb_cc_pipeline_SPOTSHADOWMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DIFFUSEMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_DIFFUSEMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DIFFUSEMAP) + +static bool js_new_cc_pipeline_DIFFUSEMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DIFFUSEMAP *result; + result = (cc::pipeline::DIFFUSEMAP *)new cc::pipeline::DIFFUSEMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DIFFUSEMAP, __jsb_cc_pipeline_DIFFUSEMAP_class, js_delete_cc_pipeline_DIFFUSEMAP) + +static bool js_delete_cc_pipeline_DIFFUSEMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DIFFUSEMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DIFFUSEMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_DIFFUSEMAP(se::Object* obj) { + auto* cls = se::Class::create("DIFFUSEMAP", obj, nullptr, _SE(js_new_cc_pipeline_DIFFUSEMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DIFFUSEMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DIFFUSEMAP_proto = cls->getProto(); + __jsb_cc_pipeline_DIFFUSEMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_JOINTTEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_JOINTTEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_JOINTTEXTURE) + +static bool js_new_cc_pipeline_JOINTTEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::JOINTTEXTURE *result; + result = (cc::pipeline::JOINTTEXTURE *)new cc::pipeline::JOINTTEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_JOINTTEXTURE, __jsb_cc_pipeline_JOINTTEXTURE_class, js_delete_cc_pipeline_JOINTTEXTURE) + +static bool js_delete_cc_pipeline_JOINTTEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_JOINTTEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::JOINTTEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_JOINTTEXTURE(se::Object* obj) { + auto* cls = se::Class::create("JOINTTEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_JOINTTEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_JOINTTEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_JOINTTEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_JOINTTEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REALTIMEJOINTTEXTURE) + +static bool js_new_cc_pipeline_REALTIMEJOINTTEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REALTIMEJOINTTEXTURE *result; + result = (cc::pipeline::REALTIMEJOINTTEXTURE *)new cc::pipeline::REALTIMEJOINTTEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REALTIMEJOINTTEXTURE, __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class, js_delete_cc_pipeline_REALTIMEJOINTTEXTURE) + +static bool js_delete_cc_pipeline_REALTIMEJOINTTEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REALTIMEJOINTTEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REALTIMEJOINTTEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REALTIMEJOINTTEXTURE(se::Object* obj) { + auto* cls = se::Class::create("REALTIMEJOINTTEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_REALTIMEJOINTTEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REALTIMEJOINTTEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_POSITIONMORPH_class = nullptr; +se::Object* __jsb_cc_pipeline_POSITIONMORPH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_POSITIONMORPH) + +static bool js_new_cc_pipeline_POSITIONMORPH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::POSITIONMORPH *result; + result = (cc::pipeline::POSITIONMORPH *)new cc::pipeline::POSITIONMORPH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_POSITIONMORPH, __jsb_cc_pipeline_POSITIONMORPH_class, js_delete_cc_pipeline_POSITIONMORPH) + +static bool js_delete_cc_pipeline_POSITIONMORPH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_POSITIONMORPH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::POSITIONMORPH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_POSITIONMORPH(se::Object* obj) { + auto* cls = se::Class::create("POSITIONMORPH", obj, nullptr, _SE(js_new_cc_pipeline_POSITIONMORPH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_POSITIONMORPH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_POSITIONMORPH_proto = cls->getProto(); + __jsb_cc_pipeline_POSITIONMORPH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_NORMALMORPH_class = nullptr; +se::Object* __jsb_cc_pipeline_NORMALMORPH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_NORMALMORPH) + +static bool js_new_cc_pipeline_NORMALMORPH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::NORMALMORPH *result; + result = (cc::pipeline::NORMALMORPH *)new cc::pipeline::NORMALMORPH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_NORMALMORPH, __jsb_cc_pipeline_NORMALMORPH_class, js_delete_cc_pipeline_NORMALMORPH) + +static bool js_delete_cc_pipeline_NORMALMORPH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_NORMALMORPH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::NORMALMORPH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_NORMALMORPH(se::Object* obj) { + auto* cls = se::Class::create("NORMALMORPH", obj, nullptr, _SE(js_new_cc_pipeline_NORMALMORPH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_NORMALMORPH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_NORMALMORPH_proto = cls->getProto(); + __jsb_cc_pipeline_NORMALMORPH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_TANGENTMORPH_class = nullptr; +se::Object* __jsb_cc_pipeline_TANGENTMORPH_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_TANGENTMORPH) + +static bool js_new_cc_pipeline_TANGENTMORPH(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::TANGENTMORPH *result; + result = (cc::pipeline::TANGENTMORPH *)new cc::pipeline::TANGENTMORPH(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_TANGENTMORPH, __jsb_cc_pipeline_TANGENTMORPH_class, js_delete_cc_pipeline_TANGENTMORPH) + +static bool js_delete_cc_pipeline_TANGENTMORPH(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_TANGENTMORPH) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::TANGENTMORPH * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_TANGENTMORPH(se::Object* obj) { + auto* cls = se::Class::create("TANGENTMORPH", obj, nullptr, _SE(js_new_cc_pipeline_TANGENTMORPH)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_TANGENTMORPH)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_TANGENTMORPH_proto = cls->getProto(); + __jsb_cc_pipeline_TANGENTMORPH_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_LIGHTMAPTEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_LIGHTMAPTEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_LIGHTMAPTEXTURE) + +static bool js_new_cc_pipeline_LIGHTMAPTEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::LIGHTMAPTEXTURE *result; + result = (cc::pipeline::LIGHTMAPTEXTURE *)new cc::pipeline::LIGHTMAPTEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_LIGHTMAPTEXTURE, __jsb_cc_pipeline_LIGHTMAPTEXTURE_class, js_delete_cc_pipeline_LIGHTMAPTEXTURE) + +static bool js_delete_cc_pipeline_LIGHTMAPTEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_LIGHTMAPTEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::LIGHTMAPTEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_LIGHTMAPTEXTURE(se::Object* obj) { + auto* cls = se::Class::create("LIGHTMAPTEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_LIGHTMAPTEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_LIGHTMAPTEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_LIGHTMAPTEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_LIGHTMAPTEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_SPRITETEXTURE_class = nullptr; +se::Object* __jsb_cc_pipeline_SPRITETEXTURE_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_SPRITETEXTURE) + +static bool js_new_cc_pipeline_SPRITETEXTURE(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::SPRITETEXTURE *result; + result = (cc::pipeline::SPRITETEXTURE *)new cc::pipeline::SPRITETEXTURE(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_SPRITETEXTURE, __jsb_cc_pipeline_SPRITETEXTURE_class, js_delete_cc_pipeline_SPRITETEXTURE) + +static bool js_delete_cc_pipeline_SPRITETEXTURE(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_SPRITETEXTURE) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPRITETEXTURE * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_SPRITETEXTURE(se::Object* obj) { + auto* cls = se::Class::create("SPRITETEXTURE", obj, nullptr, _SE(js_new_cc_pipeline_SPRITETEXTURE)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_SPRITETEXTURE)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_SPRITETEXTURE_proto = cls->getProto(); + __jsb_cc_pipeline_SPRITETEXTURE_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBECUBEMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBECUBEMAP *result; + result = (cc::pipeline::REFLECTIONPROBECUBEMAP *)new cc::pipeline::REFLECTIONPROBECUBEMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBECUBEMAP, __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class, js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBECUBEMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBECUBEMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBECUBEMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBECUBEMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBECUBEMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBEPLANARMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBEPLANARMAP *result; + result = (cc::pipeline::REFLECTIONPROBEPLANARMAP *)new cc::pipeline::REFLECTIONPROBEPLANARMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBEPLANARMAP, __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class, js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEPLANARMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBEPLANARMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBEPLANARMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBEPLANARMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBEPLANARMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBEDATAMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBEDATAMAP *result; + result = (cc::pipeline::REFLECTIONPROBEDATAMAP *)new cc::pipeline::REFLECTIONPROBEDATAMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBEDATAMAP, __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class, js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEDATAMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBEDATAMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBEDATAMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBEDATAMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBEDATAMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class = nullptr; +se::Object* __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP) + +static bool js_new_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP *result; + result = (cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP *)new cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP, __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class, js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP) + +static bool js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(se::Object* obj) { + auto* cls = se::Class::create("REFLECTIONPROBEBLENDCUBEMAP", obj, nullptr, _SE(js_new_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_proto = cls->getProto(); + __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_pipeline_localDescriptorSetLayoutResizeMaxJoints(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + + 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::pipeline::localDescriptorSetLayoutResizeMaxJoints(SWIG_STD_MOVE(arg1)); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_localDescriptorSetLayoutResizeMaxJoints) + +se::Class* __jsb_cc_pipeline_RenderPipelineInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPipelineInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipelineInfo) + +static bool js_cc_pipeline_RenderPipelineInfo_tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipelineInfo_tag_set) + +static bool js_cc_pipeline_RenderPipelineInfo_tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tag, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipelineInfo_tag_get) + +static bool js_cc_pipeline_RenderPipelineInfo_flows_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->flows, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipelineInfo_flows_set) + +static bool js_cc_pipeline_RenderPipelineInfo_flows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipelineInfo *arg1 = (cc::pipeline::RenderPipelineInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->flows, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->flows, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipelineInfo_flows_get) + +static bool js_new_cc_pipeline_RenderPipelineInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPipelineInfo *result; + result = (cc::pipeline::RenderPipelineInfo *)new cc::pipeline::RenderPipelineInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPipelineInfo, __jsb_cc_pipeline_RenderPipelineInfo_class, js_delete_cc_pipeline_RenderPipelineInfo) + +static bool js_delete_cc_pipeline_RenderPipelineInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipelineInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPipelineInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("tag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tag), ctx); + } + + + json->getProperty("flows", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->flows), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderPipelineInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderPipelineInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderPipelineInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("tag", _SE(js_cc_pipeline_RenderPipelineInfo_tag_get), _SE(js_cc_pipeline_RenderPipelineInfo_tag_set)); + cls->defineProperty("flows", _SE(js_cc_pipeline_RenderPipelineInfo_flows_get), _SE(js_cc_pipeline_RenderPipelineInfo_flows_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPipelineInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPipelineInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPipelineInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderPipeline_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipeline) + +static bool js_cc_pipeline_RenderPipeline_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderPipeline *)cc::pipeline::RenderPipeline::getInstance(); + + 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_pipeline_RenderPipeline_getInstance_static) + +static bool js_cc_pipeline_RenderPipeline_getRenderArea_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::Rect result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::pipeline::RenderPipeline::getRenderArea(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_FUNC(js_cc_pipeline_RenderPipeline_getRenderArea_static) + +static bool js_new_cc_pipeline_RenderPipeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderPipeline *result; + result = (cc::pipeline::RenderPipeline *)new cc::pipeline::RenderPipeline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderPipeline, __jsb_cc_pipeline_RenderPipeline_class, js_delete_cc_pipeline_RenderPipeline) + +static bool js_delete_cc_pipeline_RenderPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderPipeline) + +static bool js_cc_pipeline_RenderPipeline_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Swapchain *arg2 = (cc::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(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_pipeline_RenderPipeline_activate) + +static bool js_cc_pipeline_RenderPipeline_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(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_pipeline_RenderPipeline_destroy) + +static bool js_cc_pipeline_RenderPipeline_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderPipelineInfo *arg2 = 0 ; + cc::pipeline::RenderPipelineInfo 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(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)(arg1)->initialize((cc::pipeline::RenderPipelineInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_initialize) + +static bool js_cc_pipeline_RenderPipeline_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(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_pipeline_RenderPipeline_render) + +static bool js_cc_pipeline_RenderPipeline_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_onGlobalPipelineStateChanged) + +static bool js_cc_pipeline_RenderPipeline_getGlobalBindings(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::unordered_map< ccstd::string,cc::pipeline::InternalBindingInst > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::unordered_map< ccstd::string,cc::pipeline::InternalBindingInst > *) &((cc::pipeline::RenderPipeline const *)arg1)->getGlobalBindings(); + + 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_pipeline_RenderPipeline_getGlobalBindings) + +static bool js_cc_pipeline_RenderPipeline_getMacros(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::MacroRecord *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(s); + if (nullptr == arg1) return true; + result = (cc::MacroRecord *) &((cc::pipeline::RenderPipeline const *)arg1)->getMacros(); + + 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_pipeline_RenderPipeline_getMacros) + +static bool js_cc_pipeline_RenderPipeline_setValue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + int32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setValue((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_RenderPipeline_setValue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + bool arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setValue((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_RenderPipeline_setValue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(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)->setValue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_pipeline_RenderPipeline_setValue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_pipeline_RenderPipeline_setValue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_RenderPipeline_setValue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_RenderPipeline_setValue__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_setValue) + +static bool js_cc_pipeline_RenderPipeline_getCommandBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::CommandBufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::CommandBufferList *) &((cc::pipeline::RenderPipeline const *)arg1)->getCommandBuffers(); + + 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_pipeline_RenderPipeline_getCommandBuffers) + +static bool js_cc_pipeline_RenderPipeline_getQueryPools(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::QueryPoolList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::QueryPoolList *) &((cc::pipeline::RenderPipeline const *)arg1)->getQueryPools(); + + 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_pipeline_RenderPipeline_getQueryPools) + +static bool js_cc_pipeline_RenderPipeline_getPipelineUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::PipelineUBO *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::PipelineUBO *)((cc::pipeline::RenderPipeline const *)arg1)->getPipelineUBO(); + + 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_pipeline_RenderPipeline_getPipelineUBO) + +static bool js_cc_pipeline_RenderPipeline_getDevice(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Device *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)((cc::pipeline::RenderPipeline const *)arg1)->getDevice(); + + 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_pipeline_RenderPipeline_getDevice) + +static bool js_cc_pipeline_RenderPipeline_getRenderstageByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::pipeline::RenderStage *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(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::pipeline::RenderStage *)((cc::pipeline::RenderPipeline const *)arg1)->getRenderstageByName((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_pipeline_RenderPipeline_getRenderstageByName) + +static bool js_cc_pipeline_RenderPipeline_isOccluded(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::SubModel *arg3 = (cc::scene::SubModel *) NULL ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->isOccluded((cc::scene::Camera const *)arg2,(cc::scene::SubModel const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isOccluded) + +static bool js_cc_pipeline_RenderPipeline_isOcclusionQueryEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::RenderPipeline const *)arg1)->isOcclusionQueryEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isOcclusionQueryEnabled) + +static bool js_cc_pipeline_RenderPipeline_setOcclusionQueryEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOcclusionQueryEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_setOcclusionQueryEnabled) + +static bool js_cc_pipeline_RenderPipeline_isEnvmapEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::RenderPipeline const *)arg1)->isEnvmapEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isEnvmapEnabled) + +static bool js_cc_pipeline_RenderPipeline_getViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::gfx::Viewport result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getViewport(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getViewport) + +static bool js_cc_pipeline_RenderPipeline_getScissor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::gfx::Rect result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getScissor(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getScissor) + +static bool js_cc_pipeline_RenderPipeline_genQuadVertexData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::Vec4 *arg2 = 0 ; + float *arg3 ; + cc::Vec4 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->genQuadVertexData((cc::Vec4 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_genQuadVertexData) + +static bool js_cc_pipeline_RenderPipeline_getWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::pipeline::RenderPipeline const *)arg1)->getWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getWidth) + +static bool js_cc_pipeline_RenderPipeline_getHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::pipeline::RenderPipeline const *)arg1)->getHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getHeight) + +static bool js_cc_pipeline_RenderPipeline_getClearcolor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::gfx::Color result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((cc::pipeline::RenderPipeline const *)arg1)->getClearcolor(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_getClearcolor) + +static bool js_cc_pipeline_RenderPipeline_getIAByRenderArea(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Rect *arg2 = 0 ; + cc::gfx::Rect temp2 ; + cc::gfx::InputAssembler *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(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::gfx::InputAssembler *)(arg1)->getIAByRenderArea((cc::gfx::Rect 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_pipeline_RenderPipeline_getIAByRenderArea) + +static bool js_cc_pipeline_RenderPipeline_updateQuadVertexData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + cc::Vec4 temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateQuadVertexData((cc::Vec4 const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_updateQuadVertexData) + +static bool js_cc_pipeline_RenderPipeline_ensureEnoughSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(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)->ensureEnoughSize((ccstd::vector< cc::scene::Camera * > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_ensureEnoughSize) + +static bool js_cc_pipeline_RenderPipeline_createQuadInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + cc::gfx::Buffer **arg3 = (cc::gfx::Buffer **) NULL ; + cc::gfx::InputAssembler **arg4 = (cc::gfx::InputAssembler **) NULL ; + bool result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->createQuadInputAssembler(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_createQuadInputAssembler) + +static bool js_cc_pipeline_RenderPipeline_resetRenderQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resetRenderQueue(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_resetRenderQueue) + +static bool js_cc_pipeline_RenderPipeline_isRenderQueueReset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::RenderPipeline const *)arg1)->isRenderQueueReset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderPipeline_isRenderQueueReset) + +static bool js_cc_pipeline_RenderPipeline_globalDSManager_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::GlobalDSManager *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::GlobalDSManager *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_globalDSManager_get) + +static bool js_cc_pipeline_RenderPipeline_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::DescriptorSet *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_descriptorSet_get) + +static bool js_cc_pipeline_RenderPipeline_descriptorSetLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_descriptorSetLayout_get) + +static bool js_cc_pipeline_RenderPipeline_constantMacros_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_constantMacros_get) + +static bool js_cc_pipeline_RenderPipeline_clusterEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_clusterEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_clusterEnabled_set) + +static bool js_cc_pipeline_RenderPipeline_clusterEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_RenderPipeline_clusterEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline_clusterEnabled_get) + +static bool js_cc_pipeline_RenderPipeline_bloomEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_bloomEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_bloomEnabled_set) + +static bool js_cc_pipeline_RenderPipeline_bloomEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_RenderPipeline_bloomEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline_bloomEnabled_get) + +static bool js_cc_pipeline_RenderPipeline_pipelineSceneData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::PipelineSceneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::PipelineSceneData *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_pipelineSceneData_get) + +static bool js_cc_pipeline_RenderPipeline_geometryRenderer_get(se::State& s) +{ +#if CC_USE_GEOMETRY_RENDERER + + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::GeometryRenderer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::GeometryRenderer *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_geometryRenderer_get) + +static bool js_cc_pipeline_RenderPipeline_profiler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_profiler_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_profiler_set) + +static bool js_cc_pipeline_RenderPipeline_profiler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_pipeline_RenderPipeline_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_pipeline_RenderPipeline_profiler_get) + +static bool js_cc_pipeline_RenderPipeline_shadingScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_RenderPipeline_shadingScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline_shadingScale_set) + +static bool js_cc_pipeline_RenderPipeline_shadingScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_RenderPipeline_shadingScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline_shadingScale_get) + +static bool js_cc_pipeline_RenderPipeline__tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderPipeline__tag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline__tag_set) + +static bool js_cc_pipeline_RenderPipeline__tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderPipeline__tag_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderPipeline__tag_get) + +static bool js_cc_pipeline_RenderPipeline__flows_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderFlowList arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderPipeline__flows_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderPipeline__flows_set) + +static bool js_cc_pipeline_RenderPipeline__flows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderPipeline *arg1 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderFlowList result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderPipeline__flows_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_pipeline_RenderPipeline__flows_get) + +bool js_register_cc_pipeline_RenderPipeline(se::Object* obj) { + auto* cls = se::Class::create("RenderPipeline", obj, __jsb_cc_Asset_proto, _SE(js_new_cc_pipeline_RenderPipeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("globalDSManager", _SE(js_cc_pipeline_RenderPipeline_globalDSManager_get), nullptr); + cls->defineProperty("descriptorSet", _SE(js_cc_pipeline_RenderPipeline_descriptorSet_get), nullptr); + cls->defineProperty("descriptorSetLayout", _SE(js_cc_pipeline_RenderPipeline_descriptorSetLayout_get), nullptr); + cls->defineProperty("constantMacros", _SE(js_cc_pipeline_RenderPipeline_constantMacros_get), nullptr); + cls->defineProperty("clusterEnabled", _SE(js_cc_pipeline_RenderPipeline_clusterEnabled_get), _SE(js_cc_pipeline_RenderPipeline_clusterEnabled_set)); + cls->defineProperty("bloomEnabled", _SE(js_cc_pipeline_RenderPipeline_bloomEnabled_get), _SE(js_cc_pipeline_RenderPipeline_bloomEnabled_set)); + cls->defineProperty("pipelineSceneData", _SE(js_cc_pipeline_RenderPipeline_pipelineSceneData_get), nullptr); + cls->defineProperty("geometryRenderer", _SE(js_cc_pipeline_RenderPipeline_geometryRenderer_get), nullptr); + cls->defineProperty("profiler", _SE(js_cc_pipeline_RenderPipeline_profiler_get), _SE(js_cc_pipeline_RenderPipeline_profiler_set)); + cls->defineProperty("shadingScale", _SE(js_cc_pipeline_RenderPipeline_shadingScale_get), _SE(js_cc_pipeline_RenderPipeline_shadingScale_set)); + cls->defineProperty("_tag", _SE(js_cc_pipeline_RenderPipeline__tag_get), _SE(js_cc_pipeline_RenderPipeline__tag_set)); + cls->defineProperty("_flows", _SE(js_cc_pipeline_RenderPipeline__flows_get), _SE(js_cc_pipeline_RenderPipeline__flows_set)); + + cls->defineFunction("activate", _SE(js_cc_pipeline_RenderPipeline_activate)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_RenderPipeline_destroy)); + cls->defineFunction("initialize", _SE(js_cc_pipeline_RenderPipeline_initialize)); + cls->defineFunction("render", _SE(js_cc_pipeline_RenderPipeline_render)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_pipeline_RenderPipeline_onGlobalPipelineStateChanged)); + cls->defineFunction("getGlobalBindings", _SE(js_cc_pipeline_RenderPipeline_getGlobalBindings)); + cls->defineFunction("getMacros", _SE(js_cc_pipeline_RenderPipeline_getMacros)); + cls->defineFunction("setValue", _SE(js_cc_pipeline_RenderPipeline_setValue)); + cls->defineFunction("getCommandBuffers", _SE(js_cc_pipeline_RenderPipeline_getCommandBuffers)); + cls->defineFunction("getQueryPools", _SE(js_cc_pipeline_RenderPipeline_getQueryPools)); + cls->defineFunction("getPipelineUBO", _SE(js_cc_pipeline_RenderPipeline_getPipelineUBO)); + cls->defineFunction("getDevice", _SE(js_cc_pipeline_RenderPipeline_getDevice)); + cls->defineFunction("getRenderstageByName", _SE(js_cc_pipeline_RenderPipeline_getRenderstageByName)); + cls->defineFunction("isOccluded", _SE(js_cc_pipeline_RenderPipeline_isOccluded)); + cls->defineFunction("isOcclusionQueryEnabled", _SE(js_cc_pipeline_RenderPipeline_isOcclusionQueryEnabled)); + cls->defineFunction("setOcclusionQueryEnabled", _SE(js_cc_pipeline_RenderPipeline_setOcclusionQueryEnabled)); + cls->defineFunction("isEnvmapEnabled", _SE(js_cc_pipeline_RenderPipeline_isEnvmapEnabled)); + cls->defineFunction("getViewport", _SE(js_cc_pipeline_RenderPipeline_getViewport)); + cls->defineFunction("getScissor", _SE(js_cc_pipeline_RenderPipeline_getScissor)); + cls->defineFunction("genQuadVertexData", _SE(js_cc_pipeline_RenderPipeline_genQuadVertexData)); + cls->defineFunction("getWidth", _SE(js_cc_pipeline_RenderPipeline_getWidth)); + cls->defineFunction("getHeight", _SE(js_cc_pipeline_RenderPipeline_getHeight)); + cls->defineFunction("getClearcolor", _SE(js_cc_pipeline_RenderPipeline_getClearcolor)); + cls->defineFunction("getIAByRenderArea", _SE(js_cc_pipeline_RenderPipeline_getIAByRenderArea)); + cls->defineFunction("updateQuadVertexData", _SE(js_cc_pipeline_RenderPipeline_updateQuadVertexData)); + cls->defineFunction("ensureEnoughSize", _SE(js_cc_pipeline_RenderPipeline_ensureEnoughSize)); + cls->defineFunction("createQuadInputAssembler", _SE(js_cc_pipeline_RenderPipeline_createQuadInputAssembler)); + cls->defineFunction("resetRenderQueue", _SE(js_cc_pipeline_RenderPipeline_resetRenderQueue)); + cls->defineFunction("isRenderQueueReset", _SE(js_cc_pipeline_RenderPipeline_isRenderQueueReset)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_pipeline_RenderPipeline_getInstance_static)); + cls->defineStaticFunction("getRenderArea", _SE(js_cc_pipeline_RenderPipeline_getRenderArea_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderPipeline_proto = cls->getProto(); + __jsb_cc_pipeline_RenderPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderFlowInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderFlowInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlowInfo) + +static bool js_cc_pipeline_RenderFlowInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_name_set) + +static bool js_cc_pipeline_RenderFlowInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_name_get) + +static bool js_cc_pipeline_RenderFlowInfo_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_priority_set) + +static bool js_cc_pipeline_RenderFlowInfo_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_priority_get) + +static bool js_cc_pipeline_RenderFlowInfo_tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_tag_set) + +static bool js_cc_pipeline_RenderFlowInfo_tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tag, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_tag_get) + +static bool js_cc_pipeline_RenderFlowInfo_stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stages, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlowInfo_stages_set) + +static bool js_cc_pipeline_RenderFlowInfo_stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlowInfo *arg1 = (cc::pipeline::RenderFlowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stages, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->stages, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlowInfo_stages_get) + +static bool js_new_cc_pipeline_RenderFlowInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderFlowInfo *result; + result = (cc::pipeline::RenderFlowInfo *)new cc::pipeline::RenderFlowInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderFlowInfo, __jsb_cc_pipeline_RenderFlowInfo_class, js_delete_cc_pipeline_RenderFlowInfo) + +static bool js_delete_cc_pipeline_RenderFlowInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlowInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderFlowInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("tag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tag), ctx); + } + + + json->getProperty("stages", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stages), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderFlowInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderFlowInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderFlowInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_RenderFlowInfo_name_get), _SE(js_cc_pipeline_RenderFlowInfo_name_set)); + cls->defineProperty("priority", _SE(js_cc_pipeline_RenderFlowInfo_priority_get), _SE(js_cc_pipeline_RenderFlowInfo_priority_set)); + cls->defineProperty("tag", _SE(js_cc_pipeline_RenderFlowInfo_tag_get), _SE(js_cc_pipeline_RenderFlowInfo_tag_set)); + cls->defineProperty("stages", _SE(js_cc_pipeline_RenderFlowInfo_stages_get), _SE(js_cc_pipeline_RenderFlowInfo_stages_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderFlowInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderFlowInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderFlowInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlow) + +static bool js_new_cc_pipeline_RenderFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderFlow *result; + result = (cc::pipeline::RenderFlow *)new cc::pipeline::RenderFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderFlow, __jsb_cc_pipeline_RenderFlow_class, js_delete_cc_pipeline_RenderFlow) + +static bool js_delete_cc_pipeline_RenderFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderFlow) + +static bool js_cc_pipeline_RenderFlow_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderFlowInfo *arg2 = 0 ; + cc::pipeline::RenderFlowInfo 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(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)(arg1)->initialize((cc::pipeline::RenderFlowInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_initialize) + +static bool js_cc_pipeline_RenderFlow_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderPipeline *arg2 = (cc::pipeline::RenderPipeline *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_activate) + +static bool js_cc_pipeline_RenderFlow_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_render) + +static bool js_cc_pipeline_RenderFlow_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderFlow_destroy) + +static bool js_cc_pipeline_RenderFlow_getRenderstageByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::pipeline::RenderStage *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(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::pipeline::RenderStage *)((cc::pipeline::RenderFlow const *)arg1)->getRenderstageByName((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_pipeline_RenderFlow_getRenderstageByName) + +static bool js_cc_pipeline_RenderFlow__name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_pipeline_RenderFlow__name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__name_set) + +static bool js_cc_pipeline_RenderFlow__name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_pipeline_RenderFlow__name_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_pipeline_RenderFlow__name_get) + +static bool js_cc_pipeline_RenderFlow__priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderFlow__priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__priority_set) + +static bool js_cc_pipeline_RenderFlow__priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderFlow__priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlow__priority_get) + +static bool js_cc_pipeline_RenderFlow__tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderFlow__tag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__tag_set) + +static bool js_cc_pipeline_RenderFlow__tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderFlow__tag_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderFlow__tag_get) + +static bool js_cc_pipeline_RenderFlow__stages_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderStageList arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderFlow__stages_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderFlow__stages_set) + +static bool js_cc_pipeline_RenderFlow__stages_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderFlow *arg1 = (cc::pipeline::RenderFlow *) NULL ; + cc::pipeline::RenderStageList result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderFlow__stages_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_pipeline_RenderFlow__stages_get) + +bool js_register_cc_pipeline_RenderFlow(se::Object* obj) { + auto* cls = se::Class::create("RenderFlow", obj, nullptr, _SE(js_new_cc_pipeline_RenderFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_name", _SE(js_cc_pipeline_RenderFlow__name_get), _SE(js_cc_pipeline_RenderFlow__name_set)); + cls->defineProperty("_priority", _SE(js_cc_pipeline_RenderFlow__priority_get), _SE(js_cc_pipeline_RenderFlow__priority_set)); + cls->defineProperty("_tag", _SE(js_cc_pipeline_RenderFlow__tag_get), _SE(js_cc_pipeline_RenderFlow__tag_set)); + cls->defineProperty("_stages", _SE(js_cc_pipeline_RenderFlow__stages_get), _SE(js_cc_pipeline_RenderFlow__stages_set)); + + cls->defineFunction("initialize", _SE(js_cc_pipeline_RenderFlow_initialize)); + cls->defineFunction("activate", _SE(js_cc_pipeline_RenderFlow_activate)); + cls->defineFunction("render", _SE(js_cc_pipeline_RenderFlow_render)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_RenderFlow_destroy)); + cls->defineFunction("getRenderstageByName", _SE(js_cc_pipeline_RenderFlow_getRenderstageByName)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderFlow_proto = cls->getProto(); + __jsb_cc_pipeline_RenderFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderStageInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderStageInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStageInfo) + +static bool js_cc_pipeline_RenderStageInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_name_set) + +static bool js_cc_pipeline_RenderStageInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_name_get) + +static bool js_cc_pipeline_RenderStageInfo_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_priority_set) + +static bool js_cc_pipeline_RenderStageInfo_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_priority_get) + +static bool js_cc_pipeline_RenderStageInfo_tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->tag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_tag_set) + +static bool js_cc_pipeline_RenderStageInfo_tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->tag, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_tag_get) + +static bool js_cc_pipeline_RenderStageInfo_renderQueues_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderQueues, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStageInfo_renderQueues_set) + +static bool js_cc_pipeline_RenderStageInfo_renderQueues_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStageInfo *arg1 = (cc::pipeline::RenderStageInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderQueues, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderQueues, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStageInfo_renderQueues_get) + +static bool js_new_cc_pipeline_RenderStageInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderStageInfo *result; + result = (cc::pipeline::RenderStageInfo *)new cc::pipeline::RenderStageInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderStageInfo, __jsb_cc_pipeline_RenderStageInfo_class, js_delete_cc_pipeline_RenderStageInfo) + +static bool js_delete_cc_pipeline_RenderStageInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStageInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderStageInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("tag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->tag), ctx); + } + + + json->getProperty("renderQueues", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderQueues), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderStageInfo(se::Object* obj) { + auto* cls = se::Class::create("RenderStageInfo", obj, nullptr, _SE(js_new_cc_pipeline_RenderStageInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_pipeline_RenderStageInfo_name_get), _SE(js_cc_pipeline_RenderStageInfo_name_set)); + cls->defineProperty("priority", _SE(js_cc_pipeline_RenderStageInfo_priority_get), _SE(js_cc_pipeline_RenderStageInfo_priority_set)); + cls->defineProperty("tag", _SE(js_cc_pipeline_RenderStageInfo_tag_get), _SE(js_cc_pipeline_RenderStageInfo_tag_set)); + cls->defineProperty("renderQueues", _SE(js_cc_pipeline_RenderStageInfo_renderQueues_get), _SE(js_cc_pipeline_RenderStageInfo_renderQueues_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderStageInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderStageInfo_proto = cls->getProto(); + __jsb_cc_pipeline_RenderStageInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderStage_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStage) + +static bool js_new_cc_pipeline_RenderStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderStage *result; + result = (cc::pipeline::RenderStage *)new cc::pipeline::RenderStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderStage, __jsb_cc_pipeline_RenderStage_class, js_delete_cc_pipeline_RenderStage) + +static bool js_delete_cc_pipeline_RenderStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderStage) + +static bool js_cc_pipeline_RenderStage_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::pipeline::RenderPipeline *arg2 = (cc::pipeline::RenderPipeline *) NULL ; + cc::pipeline::RenderFlow *arg3 = (cc::pipeline::RenderFlow *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_activate) + +static bool js_cc_pipeline_RenderStage_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::pipeline::RenderStageInfo *arg2 = 0 ; + cc::pipeline::RenderStageInfo 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(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)(arg1)->initialize((cc::pipeline::RenderStageInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_initialize) + +static bool js_cc_pipeline_RenderStage_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_destroy) + +static bool js_cc_pipeline_RenderStage_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_RenderStage_render) + +static bool js_cc_pipeline_RenderStage_getFlow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + cc::pipeline::RenderFlow *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::RenderFlow *)((cc::pipeline::RenderStage const *)arg1)->getFlow(); + + 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_pipeline_RenderStage_getFlow) + +static bool js_cc_pipeline_RenderStage__name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_pipeline_RenderStage__name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStage__name_set) + +static bool js_cc_pipeline_RenderStage__name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_pipeline_RenderStage__name_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_pipeline_RenderStage__name_get) + +static bool js_cc_pipeline_RenderStage__priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderStage__priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStage__priority_set) + +static bool js_cc_pipeline_RenderStage__priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderStage__priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStage__priority_get) + +static bool js_cc_pipeline_RenderStage__tag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_RenderStage__tag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderStage__tag_set) + +static bool js_cc_pipeline_RenderStage__tag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderStage *arg1 = (cc::pipeline::RenderStage *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_RenderStage__tag_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderStage__tag_get) + +bool js_register_cc_pipeline_RenderStage(se::Object* obj) { + auto* cls = se::Class::create("RenderStage", obj, nullptr, _SE(js_new_cc_pipeline_RenderStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_name", _SE(js_cc_pipeline_RenderStage__name_get), _SE(js_cc_pipeline_RenderStage__name_set)); + cls->defineProperty("_priority", _SE(js_cc_pipeline_RenderStage__priority_get), _SE(js_cc_pipeline_RenderStage__priority_set)); + cls->defineProperty("_tag", _SE(js_cc_pipeline_RenderStage__tag_get), _SE(js_cc_pipeline_RenderStage__tag_set)); + + cls->defineFunction("activate", _SE(js_cc_pipeline_RenderStage_activate)); + cls->defineFunction("initialize", _SE(js_cc_pipeline_RenderStage_initialize)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_RenderStage_destroy)); + cls->defineFunction("render", _SE(js_cc_pipeline_RenderStage_render)); + cls->defineFunction("getFlow", _SE(js_cc_pipeline_RenderStage_getFlow)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderStage_proto = cls->getProto(); + __jsb_cc_pipeline_RenderStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DebugView_class = nullptr; +se::Object* __jsb_cc_pipeline_DebugView_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DebugView) + +static bool js_new_cc_pipeline_DebugView(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DebugView *result; + result = (cc::pipeline::DebugView *)new cc::pipeline::DebugView(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DebugView, __jsb_cc_pipeline_DebugView_class, js_delete_cc_pipeline_DebugView) + +static bool js_delete_cc_pipeline_DebugView(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DebugView) + +static bool js_cc_pipeline_DebugView_isCompositeModeEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + uint32_t arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)((cc::pipeline::DebugView const *)arg1)->isCompositeModeEnabled(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_isCompositeModeEnabled) + +static bool js_cc_pipeline_DebugView_enableCompositeMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + cc::pipeline::DebugViewCompositeType arg2 ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableCompositeMode(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_enableCompositeMode) + +static bool js_cc_pipeline_DebugView_enableAllCompositeMode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->enableAllCompositeMode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_enableAllCompositeMode) + +static bool js_cc_pipeline_DebugView_isEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::DebugView const *)arg1)->isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_isEnabled) + +static bool js_cc_pipeline_DebugView_reset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reset(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_DebugView_reset) + +static bool js_cc_pipeline_DebugView_singleMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + cc::pipeline::DebugViewSingleType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_DebugView_singleMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DebugView_singleMode_set) + +static bool js_cc_pipeline_DebugView_singleMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + cc::pipeline::DebugViewSingleType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::DebugViewSingleType)cc_pipeline_DebugView_singleMode_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_pipeline_DebugView_singleMode_get) + +static bool js_cc_pipeline_DebugView_lightingWithAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_DebugView_lightingWithAlbedo_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DebugView_lightingWithAlbedo_set) + +static bool js_cc_pipeline_DebugView_lightingWithAlbedo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_DebugView_lightingWithAlbedo_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DebugView_lightingWithAlbedo_get) + +static bool js_cc_pipeline_DebugView_csmLayerColoration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_DebugView_csmLayerColoration_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_DebugView_csmLayerColoration_set) + +static bool js_cc_pipeline_DebugView_csmLayerColoration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::DebugView *arg1 = (cc::pipeline::DebugView *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_DebugView_csmLayerColoration_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_DebugView_csmLayerColoration_get) + +bool js_register_cc_pipeline_DebugView(se::Object* obj) { + auto* cls = se::Class::create("DebugView", obj, nullptr, _SE(js_new_cc_pipeline_DebugView)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("singleMode", _SE(js_cc_pipeline_DebugView_singleMode_get), _SE(js_cc_pipeline_DebugView_singleMode_set)); + cls->defineProperty("lightingWithAlbedo", _SE(js_cc_pipeline_DebugView_lightingWithAlbedo_get), _SE(js_cc_pipeline_DebugView_lightingWithAlbedo_set)); + cls->defineProperty("csmLayerColoration", _SE(js_cc_pipeline_DebugView_csmLayerColoration_get), _SE(js_cc_pipeline_DebugView_csmLayerColoration_set)); + + cls->defineFunction("isCompositeModeEnabled", _SE(js_cc_pipeline_DebugView_isCompositeModeEnabled)); + cls->defineFunction("enableCompositeMode", _SE(js_cc_pipeline_DebugView_enableCompositeMode)); + cls->defineFunction("enableAllCompositeMode", _SE(js_cc_pipeline_DebugView_enableAllCompositeMode)); + cls->defineFunction("isEnabled", _SE(js_cc_pipeline_DebugView_isEnabled)); + cls->defineFunction("reset", _SE(js_cc_pipeline_DebugView_reset)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DebugView)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DebugView_proto = cls->getProto(); + __jsb_cc_pipeline_DebugView_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ForwardPipeline_class = nullptr; +se::Object* __jsb_cc_pipeline_ForwardPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardPipeline) + +static bool js_new_cc_pipeline_ForwardPipeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ForwardPipeline *result; + result = (cc::pipeline::ForwardPipeline *)new cc::pipeline::ForwardPipeline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ForwardPipeline, __jsb_cc_pipeline_ForwardPipeline_class, js_delete_cc_pipeline_ForwardPipeline) + +static bool js_delete_cc_pipeline_ForwardPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardPipeline) + +static bool js_cc_pipeline_ForwardPipeline_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) 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(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_pipeline_ForwardPipeline_destroy) + +static bool js_cc_pipeline_ForwardPipeline_getValidLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::pipeline::LightList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::LightList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getValidLights(); + + 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_pipeline_ForwardPipeline_getValidLights) + +static bool js_cc_pipeline_ForwardPipeline_getLightBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::gfx::BufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getLightBuffers(); + + 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_pipeline_ForwardPipeline_getLightBuffers) + +static bool js_cc_pipeline_ForwardPipeline_getLightIndexOffsets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getLightIndexOffsets(); + + 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_pipeline_ForwardPipeline_getLightIndexOffsets) + +static bool js_cc_pipeline_ForwardPipeline_getLightIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ForwardPipeline *arg1 = (cc::pipeline::ForwardPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::ForwardPipeline const *)arg1)->getLightIndices(); + + 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_pipeline_ForwardPipeline_getLightIndices) + +bool js_register_cc_pipeline_ForwardPipeline(se::Object* obj) { + auto* cls = se::Class::create("ForwardPipeline", obj, __jsb_cc_pipeline_RenderPipeline_proto, _SE(js_new_cc_pipeline_ForwardPipeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_pipeline_ForwardPipeline_destroy)); + cls->defineFunction("getValidLights", _SE(js_cc_pipeline_ForwardPipeline_getValidLights)); + cls->defineFunction("getLightBuffers", _SE(js_cc_pipeline_ForwardPipeline_getLightBuffers)); + cls->defineFunction("getLightIndexOffsets", _SE(js_cc_pipeline_ForwardPipeline_getLightIndexOffsets)); + cls->defineFunction("getLightIndices", _SE(js_cc_pipeline_ForwardPipeline_getLightIndices)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ForwardPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ForwardPipeline_proto = cls->getProto(); + __jsb_cc_pipeline_ForwardPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ForwardFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_ForwardFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardFlow) + +static bool js_cc_pipeline_ForwardFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::ForwardFlow::getInitializeInfo(); + + 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_pipeline_ForwardFlow_getInitializeInfo_static) + +static bool js_new_cc_pipeline_ForwardFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ForwardFlow *result; + result = (cc::pipeline::ForwardFlow *)new cc::pipeline::ForwardFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ForwardFlow, __jsb_cc_pipeline_ForwardFlow_class, js_delete_cc_pipeline_ForwardFlow) + +static bool js_delete_cc_pipeline_ForwardFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardFlow) + +bool js_register_cc_pipeline_ForwardFlow(se::Object* obj) { + auto* cls = se::Class::create("ForwardFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_ForwardFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ForwardFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ForwardFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ForwardFlow_proto = cls->getProto(); + __jsb_cc_pipeline_ForwardFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ForwardStage_class = nullptr; +se::Object* __jsb_cc_pipeline_ForwardStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardStage) + +static bool js_cc_pipeline_ForwardStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::ForwardStage::getInitializeInfo(); + + 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_pipeline_ForwardStage_getInitializeInfo_static) + +static bool js_new_cc_pipeline_ForwardStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ForwardStage *result; + result = (cc::pipeline::ForwardStage *)new cc::pipeline::ForwardStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ForwardStage, __jsb_cc_pipeline_ForwardStage_class, js_delete_cc_pipeline_ForwardStage) + +static bool js_delete_cc_pipeline_ForwardStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ForwardStage) + +bool js_register_cc_pipeline_ForwardStage(se::Object* obj) { + auto* cls = se::Class::create("ForwardStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_ForwardStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ForwardStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ForwardStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ForwardStage_proto = cls->getProto(); + __jsb_cc_pipeline_ForwardStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ShadowFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_ShadowFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowFlow) + +static bool js_new_cc_pipeline_ShadowFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ShadowFlow *result; + result = (cc::pipeline::ShadowFlow *)new cc::pipeline::ShadowFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ShadowFlow, __jsb_cc_pipeline_ShadowFlow_class, js_delete_cc_pipeline_ShadowFlow) + +static bool js_delete_cc_pipeline_ShadowFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowFlow) + +static bool js_cc_pipeline_ShadowFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::ShadowFlow::getInitializeInfo(); + + 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_pipeline_ShadowFlow_getInitializeInfo_static) + +bool js_register_cc_pipeline_ShadowFlow(se::Object* obj) { + auto* cls = se::Class::create("ShadowFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_ShadowFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ShadowFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ShadowFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ShadowFlow_proto = cls->getProto(); + __jsb_cc_pipeline_ShadowFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ShadowStage_class = nullptr; +se::Object* __jsb_cc_pipeline_ShadowStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowStage) + +static bool js_new_cc_pipeline_ShadowStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ShadowStage *result; + result = (cc::pipeline::ShadowStage *)new cc::pipeline::ShadowStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ShadowStage, __jsb_cc_pipeline_ShadowStage_class, js_delete_cc_pipeline_ShadowStage) + +static bool js_delete_cc_pipeline_ShadowStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowStage) + +static bool js_cc_pipeline_ShadowStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::ShadowStage::getInitializeInfo(); + + 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_pipeline_ShadowStage_getInitializeInfo_static) + +static bool js_cc_pipeline_ShadowStage_setFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::gfx::Framebuffer *arg2 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFramebuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowStage_setFramebuffer) + +static bool js_cc_pipeline_ShadowStage_setUsage__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + cc::scene::Light *arg3 = (cc::scene::Light *) NULL ; + cc::gfx::Framebuffer *arg4 = (cc::gfx::Framebuffer *) NULL ; + uint32_t arg5 ; + + arg1 = SE_THIS_OBJECT(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)->setUsage(arg2,(cc::scene::Light const *)arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_ShadowStage_setUsage__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + cc::scene::Light *arg3 = (cc::scene::Light *) NULL ; + cc::gfx::Framebuffer *arg4 = (cc::gfx::Framebuffer *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->setUsage(arg2,(cc::scene::Light const *)arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_ShadowStage_setUsage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_ShadowStage_setUsage__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_ShadowStage_setUsage__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowStage_setUsage) + +static bool js_cc_pipeline_ShadowStage_clearFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowStage *arg1 = (cc::pipeline::ShadowStage *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->clearFramebuffer((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowStage_clearFramebuffer) + +bool js_register_cc_pipeline_ShadowStage(se::Object* obj) { + auto* cls = se::Class::create("ShadowStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_ShadowStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFramebuffer", _SE(js_cc_pipeline_ShadowStage_setFramebuffer)); + cls->defineFunction("setUsage", _SE(js_cc_pipeline_ShadowStage_setUsage)); + cls->defineFunction("clearFramebuffer", _SE(js_cc_pipeline_ShadowStage_clearFramebuffer)); + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ShadowStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ShadowStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ShadowStage_proto = cls->getProto(); + __jsb_cc_pipeline_ShadowStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ShadowTransformInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_ShadowTransformInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowTransformInfo) + +static bool js_new_cc_pipeline_ShadowTransformInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + uint32_t arg1 ; + cc::pipeline::ShadowTransformInfo *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::pipeline::ShadowTransformInfo *)new cc::pipeline::ShadowTransformInfo(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ShadowTransformInfo, __jsb_cc_pipeline_ShadowTransformInfo_class, js_delete_cc_pipeline_ShadowTransformInfo) + +static bool js_delete_cc_pipeline_ShadowTransformInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ShadowTransformInfo) + +static bool js_cc_pipeline_ShadowTransformInfo_getLevel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::pipeline::ShadowTransformInfo const *)arg1)->getLevel(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_getLevel) + +static bool js_cc_pipeline_ShadowTransformInfo_getShadowObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::pipeline::RenderObjectList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::RenderObjectList *) &(arg1)->getShadowObjects(); + + 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_pipeline_ShadowTransformInfo_getShadowObjects) + +static bool js_cc_pipeline_ShadowTransformInfo_setShadowObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::pipeline::RenderObjectList *arg2 = 0 ; + cc::pipeline::RenderObjectList temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setShadowObjects((cc::pipeline::RenderObjectList &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setShadowObjects) + +static bool js_cc_pipeline_ShadowTransformInfo_addShadowObject(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::pipeline::RenderObject *arg2 = 0 ; + cc::pipeline::RenderObject temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addShadowObject((cc::pipeline::RenderObject &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_addShadowObject) + +static bool js_cc_pipeline_ShadowTransformInfo_clearShadowObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearShadowObjects(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_clearShadowObjects) + +static bool js_cc_pipeline_ShadowTransformInfo_getShadowCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::pipeline::ShadowTransformInfo const *)arg1)->getShadowCameraFar(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_getShadowCameraFar) + +static bool js_cc_pipeline_ShadowTransformInfo_setShadowCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowCameraFar(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setShadowCameraFar) + +static bool js_cc_pipeline_ShadowTransformInfo_getMatShadowView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getMatShadowView(); + + 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_pipeline_ShadowTransformInfo_getMatShadowView) + +static bool js_cc_pipeline_ShadowTransformInfo_setMatShadowView(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMatShadowView((cc::Mat4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setMatShadowView) + +static bool js_cc_pipeline_ShadowTransformInfo_getMatShadowProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getMatShadowProj(); + + 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_pipeline_ShadowTransformInfo_getMatShadowProj) + +static bool js_cc_pipeline_ShadowTransformInfo_setMatShadowProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMatShadowProj((cc::Mat4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setMatShadowProj) + +static bool js_cc_pipeline_ShadowTransformInfo_getMatShadowViewProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getMatShadowViewProj(); + + 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_pipeline_ShadowTransformInfo_getMatShadowViewProj) + +static bool js_cc_pipeline_ShadowTransformInfo_setMatShadowViewProj(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMatShadowViewProj((cc::Mat4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_setMatShadowViewProj) + +static bool js_cc_pipeline_ShadowTransformInfo_getValidFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *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(s); + if (nullptr == arg1) return true; + result = (geometry::Frustum *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getValidFrustum(); + + 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_pipeline_ShadowTransformInfo_getValidFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_getSplitFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *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(s); + if (nullptr == arg1) return true; + result = (geometry::Frustum *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getSplitFrustum(); + + 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_pipeline_ShadowTransformInfo_getSplitFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_getLightViewFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *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(s); + if (nullptr == arg1) return true; + result = (geometry::Frustum *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getLightViewFrustum(); + + 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_pipeline_ShadowTransformInfo_getLightViewFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_getCastLightViewBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::AABB *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(s); + if (nullptr == arg1) return true; + result = (geometry::AABB *) &((cc::pipeline::ShadowTransformInfo const *)arg1)->getCastLightViewBoundingBox(); + + 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_pipeline_ShadowTransformInfo_getCastLightViewBoundingBox) + +static bool js_cc_pipeline_ShadowTransformInfo_createMatrix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *arg2 = 0 ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + float arg4 ; + bool arg5 ; + geometry::Frustum temp2 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->createMatrix((geometry::Frustum const &)*arg2,(cc::scene::DirectionalLight const *)arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_createMatrix) + +static bool js_cc_pipeline_ShadowTransformInfo_copyToValidFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + geometry::Frustum *arg2 = 0 ; + geometry::Frustum temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->copyToValidFrustum((geometry::Frustum const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_copyToValidFrustum) + +static bool js_cc_pipeline_ShadowTransformInfo_calculateValidFrustumOrtho(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->calculateValidFrustumOrtho(arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_calculateValidFrustumOrtho) + +static bool js_cc_pipeline_ShadowTransformInfo_calculateSplitFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ShadowTransformInfo *arg1 = (cc::pipeline::ShadowTransformInfo *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + cc::Mat4 *arg6 = 0 ; + cc::Mat4 temp6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + (arg1)->calculateSplitFrustum(arg2,arg3,arg4,arg5,(cc::Mat4 const &)*arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ShadowTransformInfo_calculateSplitFrustum) + +bool js_register_cc_pipeline_ShadowTransformInfo(se::Object* obj) { + auto* cls = se::Class::create("ShadowTransformInfo", obj, nullptr, _SE(js_new_cc_pipeline_ShadowTransformInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getLevel", _SE(js_cc_pipeline_ShadowTransformInfo_getLevel)); + cls->defineFunction("getShadowObjects", _SE(js_cc_pipeline_ShadowTransformInfo_getShadowObjects)); + cls->defineFunction("setShadowObjects", _SE(js_cc_pipeline_ShadowTransformInfo_setShadowObjects)); + cls->defineFunction("addShadowObject", _SE(js_cc_pipeline_ShadowTransformInfo_addShadowObject)); + cls->defineFunction("clearShadowObjects", _SE(js_cc_pipeline_ShadowTransformInfo_clearShadowObjects)); + cls->defineFunction("getShadowCameraFar", _SE(js_cc_pipeline_ShadowTransformInfo_getShadowCameraFar)); + cls->defineFunction("setShadowCameraFar", _SE(js_cc_pipeline_ShadowTransformInfo_setShadowCameraFar)); + cls->defineFunction("getMatShadowView", _SE(js_cc_pipeline_ShadowTransformInfo_getMatShadowView)); + cls->defineFunction("setMatShadowView", _SE(js_cc_pipeline_ShadowTransformInfo_setMatShadowView)); + cls->defineFunction("getMatShadowProj", _SE(js_cc_pipeline_ShadowTransformInfo_getMatShadowProj)); + cls->defineFunction("setMatShadowProj", _SE(js_cc_pipeline_ShadowTransformInfo_setMatShadowProj)); + cls->defineFunction("getMatShadowViewProj", _SE(js_cc_pipeline_ShadowTransformInfo_getMatShadowViewProj)); + cls->defineFunction("setMatShadowViewProj", _SE(js_cc_pipeline_ShadowTransformInfo_setMatShadowViewProj)); + cls->defineFunction("getValidFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_getValidFrustum)); + cls->defineFunction("getSplitFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_getSplitFrustum)); + cls->defineFunction("getLightViewFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_getLightViewFrustum)); + cls->defineFunction("getCastLightViewBoundingBox", _SE(js_cc_pipeline_ShadowTransformInfo_getCastLightViewBoundingBox)); + cls->defineFunction("createMatrix", _SE(js_cc_pipeline_ShadowTransformInfo_createMatrix)); + cls->defineFunction("copyToValidFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_copyToValidFrustum)); + cls->defineFunction("calculateValidFrustumOrtho", _SE(js_cc_pipeline_ShadowTransformInfo_calculateValidFrustumOrtho)); + cls->defineFunction("calculateSplitFrustum", _SE(js_cc_pipeline_ShadowTransformInfo_calculateSplitFrustum)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ShadowTransformInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ShadowTransformInfo_proto = cls->getProto(); + __jsb_cc_pipeline_ShadowTransformInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_CSMLayerInfo_class = nullptr; +se::Object* __jsb_cc_pipeline_CSMLayerInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayerInfo) + +static bool js_new_cc_pipeline_CSMLayerInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + uint32_t arg1 ; + cc::pipeline::CSMLayerInfo *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::pipeline::CSMLayerInfo *)new cc::pipeline::CSMLayerInfo(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_CSMLayerInfo, __jsb_cc_pipeline_CSMLayerInfo_class, js_delete_cc_pipeline_CSMLayerInfo) + +static bool js_delete_cc_pipeline_CSMLayerInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayerInfo) + +static bool js_cc_pipeline_CSMLayerInfo_getSplitCameraNear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::pipeline::CSMLayerInfo const *)arg1)->getSplitCameraNear(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_getSplitCameraNear) + +static bool js_cc_pipeline_CSMLayerInfo_setSplitCameraNear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSplitCameraNear(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_setSplitCameraNear) + +static bool js_cc_pipeline_CSMLayerInfo_getSplitCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::pipeline::CSMLayerInfo const *)arg1)->getSplitCameraFar(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_getSplitCameraFar) + +static bool js_cc_pipeline_CSMLayerInfo_setSplitCameraFar(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSplitCameraFar(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_CSMLayerInfo_setSplitCameraFar) + +static bool js_cc_pipeline_CSMLayerInfo_getCSMAtlas(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::CSMLayerInfo *arg1 = (cc::pipeline::CSMLayerInfo *) NULL ; + cc::Vec4 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &((cc::pipeline::CSMLayerInfo const *)arg1)->getCSMAtlas(); + + 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_pipeline_CSMLayerInfo_getCSMAtlas) + +bool js_register_cc_pipeline_CSMLayerInfo(se::Object* obj) { + auto* cls = se::Class::create("CSMLayerInfo", obj, __jsb_cc_pipeline_ShadowTransformInfo_proto, _SE(js_new_cc_pipeline_CSMLayerInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getSplitCameraNear", _SE(js_cc_pipeline_CSMLayerInfo_getSplitCameraNear)); + cls->defineFunction("setSplitCameraNear", _SE(js_cc_pipeline_CSMLayerInfo_setSplitCameraNear)); + cls->defineFunction("getSplitCameraFar", _SE(js_cc_pipeline_CSMLayerInfo_getSplitCameraFar)); + cls->defineFunction("setSplitCameraFar", _SE(js_cc_pipeline_CSMLayerInfo_setSplitCameraFar)); + cls->defineFunction("getCSMAtlas", _SE(js_cc_pipeline_CSMLayerInfo_getCSMAtlas)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_CSMLayerInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_CSMLayerInfo_proto = cls->getProto(); + __jsb_cc_pipeline_CSMLayerInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_CSMLayers_class = nullptr; +se::Object* __jsb_cc_pipeline_CSMLayers_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayers) + +static bool js_new_cc_pipeline_CSMLayers(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::CSMLayers *result; + result = (cc::pipeline::CSMLayers *)new cc::pipeline::CSMLayers(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_CSMLayers, __jsb_cc_pipeline_CSMLayers_class, js_delete_cc_pipeline_CSMLayers) + +static bool js_delete_cc_pipeline_CSMLayers(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_CSMLayers) + +bool js_register_cc_pipeline_CSMLayers(se::Object* obj) { + auto* cls = se::Class::create("CSMLayers", obj, nullptr, _SE(js_new_cc_pipeline_CSMLayers)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_CSMLayers)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_CSMLayers_proto = cls->getProto(); + __jsb_cc_pipeline_CSMLayers_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_GlobalDSManager_class = nullptr; +se::Object* __jsb_cc_pipeline_GlobalDSManager_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_GlobalDSManager) + +static bool js_new_cc_pipeline_GlobalDSManager(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::GlobalDSManager *result; + result = (cc::pipeline::GlobalDSManager *)new cc::pipeline::GlobalDSManager(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_GlobalDSManager, __jsb_cc_pipeline_GlobalDSManager_class, js_delete_cc_pipeline_GlobalDSManager) + +static bool js_delete_cc_pipeline_GlobalDSManager(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_GlobalDSManager) + +static bool js_cc_pipeline_GlobalDSManager_getLinearSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::pipeline::GlobalDSManager const *)arg1)->getLinearSampler(); + + 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_pipeline_GlobalDSManager_getLinearSampler) + +static bool js_cc_pipeline_GlobalDSManager_getPointSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::pipeline::GlobalDSManager const *)arg1)->getPointSampler(); + + 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_pipeline_GlobalDSManager_getPointSampler) + +static bool js_cc_pipeline_GlobalDSManager_getDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::DescriptorSetLayout *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)((cc::pipeline::GlobalDSManager const *)arg1)->getDescriptorSetLayout(); + + 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_pipeline_GlobalDSManager_getDescriptorSetLayout) + +static bool js_cc_pipeline_GlobalDSManager_getGlobalDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)((cc::pipeline::GlobalDSManager const *)arg1)->getGlobalDescriptorSet(); + + 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_pipeline_GlobalDSManager_getGlobalDescriptorSet) + +static bool js_cc_pipeline_GlobalDSManager_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_activate) + +static bool js_cc_pipeline_GlobalDSManager_bindBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + uint32_t arg2 ; + cc::gfx::Buffer *arg3 = (cc::gfx::Buffer *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindBuffer(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_bindBuffer) + +static bool js_cc_pipeline_GlobalDSManager_bindTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_bindTexture) + +static bool js_cc_pipeline_GlobalDSManager_bindSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_bindSampler) + +static bool js_cc_pipeline_GlobalDSManager_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_update) + +static bool js_cc_pipeline_GlobalDSManager_getOrCreateDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::DescriptorSet *)(arg1)->getOrCreateDescriptorSet((cc::scene::Light 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_pipeline_GlobalDSManager_getOrCreateDescriptorSet) + +static bool js_cc_pipeline_GlobalDSManager_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GlobalDSManager *arg1 = (cc::pipeline::GlobalDSManager *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_destroy) + +static bool js_cc_pipeline_GlobalDSManager_setDescriptorSetLayout_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::pipeline::GlobalDSManager::setDescriptorSetLayout(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GlobalDSManager_setDescriptorSetLayout_static) + +bool js_register_cc_pipeline_GlobalDSManager(se::Object* obj) { + auto* cls = se::Class::create("GlobalDSManager", obj, nullptr, _SE(js_new_cc_pipeline_GlobalDSManager)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getLinearSampler", _SE(js_cc_pipeline_GlobalDSManager_getLinearSampler)); + cls->defineFunction("getPointSampler", _SE(js_cc_pipeline_GlobalDSManager_getPointSampler)); + cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_pipeline_GlobalDSManager_getDescriptorSetLayout)); + cls->defineFunction("getGlobalDescriptorSet", _SE(js_cc_pipeline_GlobalDSManager_getGlobalDescriptorSet)); + cls->defineFunction("activate", _SE(js_cc_pipeline_GlobalDSManager_activate)); + cls->defineFunction("bindBuffer", _SE(js_cc_pipeline_GlobalDSManager_bindBuffer)); + cls->defineFunction("bindTexture", _SE(js_cc_pipeline_GlobalDSManager_bindTexture)); + cls->defineFunction("bindSampler", _SE(js_cc_pipeline_GlobalDSManager_bindSampler)); + cls->defineFunction("update", _SE(js_cc_pipeline_GlobalDSManager_update)); + cls->defineFunction("getOrCreateDescriptorSet", _SE(js_cc_pipeline_GlobalDSManager_getOrCreateDescriptorSet)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_GlobalDSManager_destroy)); + + + cls->defineStaticFunction("setDescriptorSetLayout", _SE(js_cc_pipeline_GlobalDSManager_setDescriptorSetLayout_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_GlobalDSManager)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_GlobalDSManager_proto = cls->getProto(); + __jsb_cc_pipeline_GlobalDSManager_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_InstancedItem_class = nullptr; +se::Object* __jsb_cc_pipeline_InstancedItem_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedItem) + +static bool js_cc_pipeline_InstancedItem_capacity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->capacity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_capacity_set) + +static bool js_cc_pipeline_InstancedItem_capacity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->capacity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_capacity_get) + +static bool js_cc_pipeline_InstancedItem_vb_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vb, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_vb_set) + +static bool js_cc_pipeline_InstancedItem_vb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vb, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vb, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_vb_get) + +static bool js_cc_pipeline_InstancedItem_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_data_set) + +static bool js_cc_pipeline_InstancedItem_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_data_get) + +static bool js_cc_pipeline_InstancedItem_ia_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->ia, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_ia_set) + +static bool js_cc_pipeline_InstancedItem_ia_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->ia, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->ia, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_ia_get) + +static bool js_cc_pipeline_InstancedItem_stride_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->stride, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_stride_set) + +static bool js_cc_pipeline_InstancedItem_stride_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->stride, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_stride_get) + +static bool js_cc_pipeline_InstancedItem_shader_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->shader, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_shader_set) + +static bool js_cc_pipeline_InstancedItem_shader_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->shader, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->shader, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_shader_get) + +static bool js_cc_pipeline_InstancedItem_descriptorSet_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->descriptorSet, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_descriptorSet_set) + +static bool js_cc_pipeline_InstancedItem_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->descriptorSet, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->descriptorSet, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_descriptorSet_get) + +static bool js_cc_pipeline_InstancedItem_lightingMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->lightingMap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_lightingMap_set) + +static bool js_cc_pipeline_InstancedItem_lightingMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->lightingMap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->lightingMap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_lightingMap_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeCubemap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbeCubemap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeCubemap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbeCubemap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->reflectionProbeCubemap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbePlanarMap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbePlanarMap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->reflectionProbePlanarMap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbeType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbeType_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbeType, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbeType_get) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->reflectionProbeBlendCubemap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_set) + +static bool js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->reflectionProbeBlendCubemap, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->reflectionProbeBlendCubemap, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_get) + +static bool js_cc_pipeline_InstancedItem_drawInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->drawInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_InstancedItem_drawInfo_set) + +static bool js_cc_pipeline_InstancedItem_drawInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::InstancedItem *arg1 = (cc::pipeline::InstancedItem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->drawInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->drawInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_InstancedItem_drawInfo_get) + +static bool js_new_cc_pipeline_InstancedItem(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::InstancedItem *result; + result = (cc::pipeline::InstancedItem *)new cc::pipeline::InstancedItem(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InstancedItem, __jsb_cc_pipeline_InstancedItem_class, js_delete_cc_pipeline_InstancedItem) + +static bool js_delete_cc_pipeline_InstancedItem(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedItem) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InstancedItem * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("capacity", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->capacity), ctx); + } + + + json->getProperty("vb", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->vb), ctx); + } + + + json->getProperty("data", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->data), ctx); + } + + + json->getProperty("ia", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->ia), ctx); + } + + + json->getProperty("stride", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->stride), ctx); + } + + + json->getProperty("shader", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->shader), ctx); + } + + + json->getProperty("descriptorSet", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->descriptorSet), ctx); + } + + + json->getProperty("lightingMap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->lightingMap), ctx); + } + + + json->getProperty("reflectionProbeCubemap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbeCubemap), ctx); + } + + + json->getProperty("reflectionProbePlanarMap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbePlanarMap), ctx); + } + + + json->getProperty("reflectionProbeType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbeType), ctx); + } + + + json->getProperty("reflectionProbeBlendCubemap", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->reflectionProbeBlendCubemap), ctx); + } + + + json->getProperty("drawInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->drawInfo), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_InstancedItem(se::Object* obj) { + auto* cls = se::Class::create("InstancedItem", obj, nullptr, _SE(js_new_cc_pipeline_InstancedItem)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("capacity", _SE(js_cc_pipeline_InstancedItem_capacity_get), _SE(js_cc_pipeline_InstancedItem_capacity_set)); + cls->defineProperty("vb", _SE(js_cc_pipeline_InstancedItem_vb_get), _SE(js_cc_pipeline_InstancedItem_vb_set)); + cls->defineProperty("data", _SE(js_cc_pipeline_InstancedItem_data_get), _SE(js_cc_pipeline_InstancedItem_data_set)); + cls->defineProperty("ia", _SE(js_cc_pipeline_InstancedItem_ia_get), _SE(js_cc_pipeline_InstancedItem_ia_set)); + cls->defineProperty("stride", _SE(js_cc_pipeline_InstancedItem_stride_get), _SE(js_cc_pipeline_InstancedItem_stride_set)); + cls->defineProperty("shader", _SE(js_cc_pipeline_InstancedItem_shader_get), _SE(js_cc_pipeline_InstancedItem_shader_set)); + cls->defineProperty("descriptorSet", _SE(js_cc_pipeline_InstancedItem_descriptorSet_get), _SE(js_cc_pipeline_InstancedItem_descriptorSet_set)); + cls->defineProperty("lightingMap", _SE(js_cc_pipeline_InstancedItem_lightingMap_get), _SE(js_cc_pipeline_InstancedItem_lightingMap_set)); + cls->defineProperty("reflectionProbeCubemap", _SE(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbeCubemap_set)); + cls->defineProperty("reflectionProbePlanarMap", _SE(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbePlanarMap_set)); + cls->defineProperty("reflectionProbeType", _SE(js_cc_pipeline_InstancedItem_reflectionProbeType_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbeType_set)); + cls->defineProperty("reflectionProbeBlendCubemap", _SE(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_get), _SE(js_cc_pipeline_InstancedItem_reflectionProbeBlendCubemap_set)); + cls->defineProperty("drawInfo", _SE(js_cc_pipeline_InstancedItem_drawInfo_get), _SE(js_cc_pipeline_InstancedItem_drawInfo_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InstancedItem)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InstancedItem_proto = cls->getProto(); + __jsb_cc_pipeline_InstancedItem_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_InstancedBuffer_class = nullptr; +se::Object* __jsb_cc_pipeline_InstancedBuffer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedBuffer) + +static bool js_new_cc_pipeline_InstancedBuffer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::InstancedBuffer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::pipeline::InstancedBuffer *)new cc::pipeline::InstancedBuffer((cc::scene::Pass const *)arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_InstancedBuffer, __jsb_cc_pipeline_InstancedBuffer_class, js_delete_cc_pipeline_InstancedBuffer) + +static bool js_delete_cc_pipeline_InstancedBuffer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_InstancedBuffer) + +static bool js_cc_pipeline_InstancedBuffer_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_destroy) + +static bool js_cc_pipeline_InstancedBuffer_merge__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::SubModel *arg2 = (cc::scene::SubModel *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(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)->merge(arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_InstancedBuffer_merge__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::SubModel *arg2 = (cc::scene::SubModel *) NULL ; + uint32_t arg3 ; + cc::gfx::Shader *arg4 = (cc::gfx::Shader *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->merge(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_InstancedBuffer_merge(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_pipeline_InstancedBuffer_merge__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_InstancedBuffer_merge__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_merge) + +static bool js_cc_pipeline_InstancedBuffer_uploadBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::gfx::CommandBuffer *arg2 = (cc::gfx::CommandBuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((cc::pipeline::InstancedBuffer const *)arg1)->uploadBuffers(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_uploadBuffers) + +static bool js_cc_pipeline_InstancedBuffer_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_clear) + +static bool js_cc_pipeline_InstancedBuffer_setDynamicOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDynamicOffset(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_setDynamicOffset) + +static bool js_cc_pipeline_InstancedBuffer_getInstances(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::pipeline::InstancedItemList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::InstancedItemList *) &((cc::pipeline::InstancedBuffer const *)arg1)->getInstances(); + + 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_pipeline_InstancedBuffer_getInstances) + +static bool js_cc_pipeline_InstancedBuffer_getSortRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::pipeline::RenderPass *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::RenderPass *) &((cc::pipeline::InstancedBuffer const *)arg1)->getSortRender(); + + 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_pipeline_InstancedBuffer_getSortRender) + +static bool js_cc_pipeline_InstancedBuffer_getPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)((cc::pipeline::InstancedBuffer const *)arg1)->getPass(); + + 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_pipeline_InstancedBuffer_getPass) + +static bool js_cc_pipeline_InstancedBuffer_setPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::scene::Pass *arg2 = (cc::scene::Pass *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPass((cc::scene::Pass const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_setPass) + +static bool js_cc_pipeline_InstancedBuffer_hasPendingModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::InstancedBuffer const *)arg1)->hasPendingModels(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_InstancedBuffer_hasPendingModels) + +static bool js_cc_pipeline_InstancedBuffer_dynamicOffsets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::InstancedBuffer *arg1 = (cc::pipeline::InstancedBuffer *) NULL ; + cc::pipeline::DynamicOffsetList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::DynamicOffsetList *) &((cc::pipeline::InstancedBuffer const *)arg1)->dynamicOffsets(); + + 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_pipeline_InstancedBuffer_dynamicOffsets) + +bool js_register_cc_pipeline_InstancedBuffer(se::Object* obj) { + auto* cls = se::Class::create("InstancedBuffer", obj, nullptr, _SE(js_new_cc_pipeline_InstancedBuffer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_pipeline_InstancedBuffer_destroy)); + cls->defineFunction("merge", _SE(js_cc_pipeline_InstancedBuffer_merge)); + cls->defineFunction("uploadBuffers", _SE(js_cc_pipeline_InstancedBuffer_uploadBuffers)); + cls->defineFunction("clear", _SE(js_cc_pipeline_InstancedBuffer_clear)); + cls->defineFunction("setDynamicOffset", _SE(js_cc_pipeline_InstancedBuffer_setDynamicOffset)); + cls->defineFunction("getInstances", _SE(js_cc_pipeline_InstancedBuffer_getInstances)); + cls->defineFunction("getSortRender", _SE(js_cc_pipeline_InstancedBuffer_getSortRender)); + cls->defineFunction("getPass", _SE(js_cc_pipeline_InstancedBuffer_getPass)); + cls->defineFunction("setPass", _SE(js_cc_pipeline_InstancedBuffer_setPass)); + cls->defineFunction("hasPendingModels", _SE(js_cc_pipeline_InstancedBuffer_hasPendingModels)); + cls->defineFunction("dynamicOffsets", _SE(js_cc_pipeline_InstancedBuffer_dynamicOffsets)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_InstancedBuffer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_InstancedBuffer_proto = cls->getProto(); + __jsb_cc_pipeline_InstancedBuffer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_DeferredPipeline_class = nullptr; +se::Object* __jsb_cc_pipeline_DeferredPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_DeferredPipeline) + +static bool js_new_cc_pipeline_DeferredPipeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::DeferredPipeline *result; + result = (cc::pipeline::DeferredPipeline *)new cc::pipeline::DeferredPipeline(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_DeferredPipeline, __jsb_cc_pipeline_DeferredPipeline_class, js_delete_cc_pipeline_DeferredPipeline) + +static bool js_delete_cc_pipeline_DeferredPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_DeferredPipeline) + +static bool js_cc_pipeline_DeferredPipeline_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) 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(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_pipeline_DeferredPipeline_destroy) + +static bool js_cc_pipeline_DeferredPipeline_getLightsUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::pipeline::DeferredPipeline const *)arg1)->getLightsUBO(); + + 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_pipeline_DeferredPipeline_getLightsUBO) + +static bool js_cc_pipeline_DeferredPipeline_getValidLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::pipeline::LightList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::LightList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getValidLights(); + + 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_pipeline_DeferredPipeline_getValidLights) + +static bool js_cc_pipeline_DeferredPipeline_getLightBuffers(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::gfx::BufferList *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BufferList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getLightBuffers(); + + 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_pipeline_DeferredPipeline_getLightBuffers) + +static bool js_cc_pipeline_DeferredPipeline_getLightIndexOffsets(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getLightIndexOffsets(); + + 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_pipeline_DeferredPipeline_getLightIndexOffsets) + +static bool js_cc_pipeline_DeferredPipeline_getLightIndices(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::DeferredPipeline *arg1 = (cc::pipeline::DeferredPipeline *) NULL ; + cc::pipeline::UintList *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::UintList *) &((cc::pipeline::DeferredPipeline const *)arg1)->getLightIndices(); + + 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_pipeline_DeferredPipeline_getLightIndices) + +bool js_register_cc_pipeline_DeferredPipeline(se::Object* obj) { + auto* cls = se::Class::create("DeferredPipeline", obj, __jsb_cc_pipeline_RenderPipeline_proto, _SE(js_new_cc_pipeline_DeferredPipeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("destroy", _SE(js_cc_pipeline_DeferredPipeline_destroy)); + cls->defineFunction("getLightsUBO", _SE(js_cc_pipeline_DeferredPipeline_getLightsUBO)); + cls->defineFunction("getValidLights", _SE(js_cc_pipeline_DeferredPipeline_getValidLights)); + cls->defineFunction("getLightBuffers", _SE(js_cc_pipeline_DeferredPipeline_getLightBuffers)); + cls->defineFunction("getLightIndexOffsets", _SE(js_cc_pipeline_DeferredPipeline_getLightIndexOffsets)); + cls->defineFunction("getLightIndices", _SE(js_cc_pipeline_DeferredPipeline_getLightIndices)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_DeferredPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_DeferredPipeline_proto = cls->getProto(); + __jsb_cc_pipeline_DeferredPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_MainFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_MainFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_MainFlow) + +static bool js_cc_pipeline_MainFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::MainFlow::getInitializeInfo(); + + 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_pipeline_MainFlow_getInitializeInfo_static) + +static bool js_new_cc_pipeline_MainFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::MainFlow *result; + result = (cc::pipeline::MainFlow *)new cc::pipeline::MainFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_MainFlow, __jsb_cc_pipeline_MainFlow_class, js_delete_cc_pipeline_MainFlow) + +static bool js_delete_cc_pipeline_MainFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_MainFlow) + +bool js_register_cc_pipeline_MainFlow(se::Object* obj) { + auto* cls = se::Class::create("MainFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_MainFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_MainFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_MainFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_MainFlow_proto = cls->getProto(); + __jsb_cc_pipeline_MainFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_GbufferStage_class = nullptr; +se::Object* __jsb_cc_pipeline_GbufferStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_GbufferStage) + +static bool js_cc_pipeline_GbufferStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::GbufferStage::getInitializeInfo(); + + 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_pipeline_GbufferStage_getInitializeInfo_static) + +static bool js_new_cc_pipeline_GbufferStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::GbufferStage *result; + result = (cc::pipeline::GbufferStage *)new cc::pipeline::GbufferStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_GbufferStage, __jsb_cc_pipeline_GbufferStage_class, js_delete_cc_pipeline_GbufferStage) + +static bool js_delete_cc_pipeline_GbufferStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_GbufferStage) + +bool js_register_cc_pipeline_GbufferStage(se::Object* obj) { + auto* cls = se::Class::create("GbufferStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_GbufferStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_GbufferStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_GbufferStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_GbufferStage_proto = cls->getProto(); + __jsb_cc_pipeline_GbufferStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_RenderElem_class = nullptr; +se::Object* __jsb_cc_pipeline_RenderElem_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_RenderElem) + +static bool js_cc_pipeline_RenderElem_renderObject_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderObject, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_renderObject_set) + +static bool js_cc_pipeline_RenderElem_renderObject_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderObject, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderObject, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_renderObject_get) + +static bool js_cc_pipeline_RenderElem_set_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->set, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_set_set) + +static bool js_cc_pipeline_RenderElem_set_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->set, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->set, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_set_get) + +static bool js_cc_pipeline_RenderElem_modelIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->modelIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_modelIndex_set) + +static bool js_cc_pipeline_RenderElem_modelIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->modelIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_modelIndex_get) + +static bool js_cc_pipeline_RenderElem_passIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->passIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_RenderElem_passIndex_set) + +static bool js_cc_pipeline_RenderElem_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::RenderElem *arg1 = (cc::pipeline::RenderElem *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->passIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_RenderElem_passIndex_get) + +static bool js_new_cc_pipeline_RenderElem(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::RenderElem *result; + result = (cc::pipeline::RenderElem *)new cc::pipeline::RenderElem(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_RenderElem, __jsb_cc_pipeline_RenderElem_class, js_delete_cc_pipeline_RenderElem) + +static bool js_delete_cc_pipeline_RenderElem(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_RenderElem) + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderElem * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("renderObject", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderObject), ctx); + } + + + json->getProperty("set", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->set), ctx); + } + + + json->getProperty("modelIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->modelIndex), ctx); + } + + + json->getProperty("passIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->passIndex), ctx); + } + + + return ok; +} + + +bool js_register_cc_pipeline_RenderElem(se::Object* obj) { + auto* cls = se::Class::create("RenderElem", obj, nullptr, _SE(js_new_cc_pipeline_RenderElem)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("renderObject", _SE(js_cc_pipeline_RenderElem_renderObject_get), _SE(js_cc_pipeline_RenderElem_renderObject_set)); + cls->defineProperty("set", _SE(js_cc_pipeline_RenderElem_set_get), _SE(js_cc_pipeline_RenderElem_set_set)); + cls->defineProperty("modelIndex", _SE(js_cc_pipeline_RenderElem_modelIndex_get), _SE(js_cc_pipeline_RenderElem_modelIndex_set)); + cls->defineProperty("passIndex", _SE(js_cc_pipeline_RenderElem_passIndex_get), _SE(js_cc_pipeline_RenderElem_passIndex_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_RenderElem)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_RenderElem_proto = cls->getProto(); + __jsb_cc_pipeline_RenderElem_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_LightingStage_class = nullptr; +se::Object* __jsb_cc_pipeline_LightingStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_LightingStage) + +static bool js_cc_pipeline_LightingStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::LightingStage::getInitializeInfo(); + + 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_pipeline_LightingStage_getInitializeInfo_static) + +static bool js_new_cc_pipeline_LightingStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::LightingStage *result; + result = (cc::pipeline::LightingStage *)new cc::pipeline::LightingStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_LightingStage, __jsb_cc_pipeline_LightingStage_class, js_delete_cc_pipeline_LightingStage) + +static bool js_delete_cc_pipeline_LightingStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_LightingStage) + +bool js_register_cc_pipeline_LightingStage(se::Object* obj) { + auto* cls = se::Class::create("LightingStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_LightingStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_LightingStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_LightingStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_LightingStage_proto = cls->getProto(); + __jsb_cc_pipeline_LightingStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_BloomStage_class = nullptr; +se::Object* __jsb_cc_pipeline_BloomStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_BloomStage) + +static bool js_new_cc_pipeline_BloomStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::BloomStage *result; + result = (cc::pipeline::BloomStage *)new cc::pipeline::BloomStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_BloomStage, __jsb_cc_pipeline_BloomStage_class, js_delete_cc_pipeline_BloomStage) + +static bool js_delete_cc_pipeline_BloomStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_BloomStage) + +static bool js_cc_pipeline_BloomStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::BloomStage::getInitializeInfo(); + + 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_pipeline_BloomStage_getInitializeInfo_static) + +static bool js_cc_pipeline_BloomStage_getPrefilterUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)(arg1)->getPrefilterUBO(); + + 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_pipeline_BloomStage_getPrefilterUBO) + +static bool js_cc_pipeline_BloomStage_getDownsampleUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::pipeline::BloomStage::SampleUBOArray *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::BloomStage::SampleUBOArray *) &(arg1)->getDownsampleUBO(); + + 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_pipeline_BloomStage_getDownsampleUBO) + +static bool js_cc_pipeline_BloomStage_getUpsampleUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::pipeline::BloomStage::SampleUBOArray *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(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::BloomStage::SampleUBOArray *) &(arg1)->getUpsampleUBO(); + + 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_pipeline_BloomStage_getUpsampleUBO) + +static bool js_cc_pipeline_BloomStage_getCombineUBO(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)(arg1)->getCombineUBO(); + + 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_pipeline_BloomStage_getCombineUBO) + +static bool js_cc_pipeline_BloomStage_getSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + cc::gfx::Sampler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Sampler *)((cc::pipeline::BloomStage const *)arg1)->getSampler(); + + 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_pipeline_BloomStage_getSampler) + +static bool js_cc_pipeline_BloomStage_threshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_BloomStage_threshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_BloomStage_threshold_set) + +static bool js_cc_pipeline_BloomStage_threshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_BloomStage_threshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_BloomStage_threshold_get) + +static bool js_cc_pipeline_BloomStage_intensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_BloomStage_intensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_BloomStage_intensity_set) + +static bool js_cc_pipeline_BloomStage_intensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_BloomStage_intensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_BloomStage_intensity_get) + +static bool js_cc_pipeline_BloomStage_iterations_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_BloomStage_iterations_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_BloomStage_iterations_set) + +static bool js_cc_pipeline_BloomStage_iterations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::BloomStage *arg1 = (cc::pipeline::BloomStage *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)cc_pipeline_BloomStage_iterations_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_BloomStage_iterations_get) + +bool js_register_cc_pipeline_BloomStage(se::Object* obj) { + auto* cls = se::Class::create("BloomStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_BloomStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("threshold", _SE(js_cc_pipeline_BloomStage_threshold_get), _SE(js_cc_pipeline_BloomStage_threshold_set)); + cls->defineProperty("intensity", _SE(js_cc_pipeline_BloomStage_intensity_get), _SE(js_cc_pipeline_BloomStage_intensity_set)); + cls->defineProperty("iterations", _SE(js_cc_pipeline_BloomStage_iterations_get), _SE(js_cc_pipeline_BloomStage_iterations_set)); + + cls->defineFunction("getPrefilterUBO", _SE(js_cc_pipeline_BloomStage_getPrefilterUBO)); + cls->defineFunction("getDownsampleUBO", _SE(js_cc_pipeline_BloomStage_getDownsampleUBO)); + cls->defineFunction("getUpsampleUBO", _SE(js_cc_pipeline_BloomStage_getUpsampleUBO)); + cls->defineFunction("getCombineUBO", _SE(js_cc_pipeline_BloomStage_getCombineUBO)); + cls->defineFunction("getSampler", _SE(js_cc_pipeline_BloomStage_getSampler)); + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_BloomStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_BloomStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_BloomStage_proto = cls->getProto(); + __jsb_cc_pipeline_BloomStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_PostProcessStage_class = nullptr; +se::Object* __jsb_cc_pipeline_PostProcessStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_PostProcessStage) + +static bool js_new_cc_pipeline_PostProcessStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::PostProcessStage *result; + result = (cc::pipeline::PostProcessStage *)new cc::pipeline::PostProcessStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_PostProcessStage, __jsb_cc_pipeline_PostProcessStage_class, js_delete_cc_pipeline_PostProcessStage) + +static bool js_delete_cc_pipeline_PostProcessStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_PostProcessStage) + +static bool js_cc_pipeline_PostProcessStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::PostProcessStage::getInitializeInfo(); + + 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_pipeline_PostProcessStage_getInitializeInfo_static) + +bool js_register_cc_pipeline_PostProcessStage(se::Object* obj) { + auto* cls = se::Class::create("PostProcessStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_PostProcessStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_PostProcessStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_PostProcessStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_PostProcessStage_proto = cls->getProto(); + __jsb_cc_pipeline_PostProcessStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_PipelineSceneData_class = nullptr; +se::Object* __jsb_cc_pipeline_PipelineSceneData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_PipelineSceneData) + +static bool js_new_cc_pipeline_PipelineSceneData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::PipelineSceneData *result; + result = (cc::pipeline::PipelineSceneData *)new cc::pipeline::PipelineSceneData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_PipelineSceneData, __jsb_cc_pipeline_PipelineSceneData_class, js_delete_cc_pipeline_PipelineSceneData) + +static bool js_delete_cc_pipeline_PipelineSceneData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_PipelineSceneData) + +static bool js_cc_pipeline_PipelineSceneData_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_activate) + +static bool js_cc_pipeline_PipelineSceneData_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_destroy) + +static bool js_cc_pipeline_PipelineSceneData_updatePipelineSceneData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updatePipelineSceneData(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_updatePipelineSceneData) + +static bool js_cc_pipeline_PipelineSceneData_setShadowFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + cc::gfx::Framebuffer *arg3 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setShadowFramebuffer((cc::scene::Light const *)arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_setShadowFramebuffer) + +static bool js_cc_pipeline_PipelineSceneData_getOctree(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Octree *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Octree *)((cc::pipeline::PipelineSceneData const *)arg1)->getOctree(); + + 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_pipeline_PipelineSceneData_getOctree) + +static bool js_cc_pipeline_PipelineSceneData_getOcclusionQueryInputAssembler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::InputAssembler *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssembler *)((cc::pipeline::PipelineSceneData const *)arg1)->getOcclusionQueryInputAssembler(); + + 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_pipeline_PipelineSceneData_getOcclusionQueryInputAssembler) + +static bool js_cc_pipeline_PipelineSceneData_getOcclusionQueryPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)((cc::pipeline::PipelineSceneData const *)arg1)->getOcclusionQueryPass(); + + 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_pipeline_PipelineSceneData_getOcclusionQueryPass) + +static bool js_cc_pipeline_PipelineSceneData_getOcclusionQueryShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::Shader *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)((cc::pipeline::PipelineSceneData const *)arg1)->getOcclusionQueryShader(); + + 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_pipeline_PipelineSceneData_getOcclusionQueryShader) + +static bool js_cc_pipeline_PipelineSceneData_getGeometryRendererMaterials(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::Material > > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::Material > > *) &((cc::pipeline::PipelineSceneData const *)arg1)->getGeometryRendererMaterials(); + + 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_pipeline_PipelineSceneData_getGeometryRendererMaterials) + +static bool js_cc_pipeline_PipelineSceneData_getGeometryRendererPasses(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::scene::Pass * > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::scene::Pass * > *) &((cc::pipeline::PipelineSceneData const *)arg1)->getGeometryRendererPasses(); + + 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_pipeline_PipelineSceneData_getGeometryRendererPasses) + +static bool js_cc_pipeline_PipelineSceneData_getGeometryRendererShaders(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::gfx::Shader * > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::gfx::Shader * > *) &((cc::pipeline::PipelineSceneData const *)arg1)->getGeometryRendererShaders(); + + 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_pipeline_PipelineSceneData_getGeometryRendererShaders) + +static bool js_cc_pipeline_PipelineSceneData_getDebugRendererPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)((cc::pipeline::PipelineSceneData const *)arg1)->getDebugRendererPass(); + + 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_pipeline_PipelineSceneData_getDebugRendererPass) + +static bool js_cc_pipeline_PipelineSceneData_getDebugRendererShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gfx::Shader *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)((cc::pipeline::PipelineSceneData const *)arg1)->getDebugRendererShader(); + + 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_pipeline_PipelineSceneData_getDebugRendererShader) + +static bool js_cc_pipeline_PipelineSceneData_addRenderObject(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::pipeline::RenderObject *arg2 = 0 ; + cc::pipeline::RenderObject temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->addRenderObject((cc::pipeline::RenderObject &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_addRenderObject) + +static bool js_cc_pipeline_PipelineSceneData_clearRenderObjects(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearRenderObjects(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_clearRenderObjects) + +static bool js_cc_pipeline_PipelineSceneData_addValidPunctualLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addValidPunctualLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_addValidPunctualLight) + +static bool js_cc_pipeline_PipelineSceneData_clearValidPunctualLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearValidPunctualLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_clearValidPunctualLights) + +static bool js_cc_pipeline_PipelineSceneData_setCSMSupported(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCSMSupported(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_PipelineSceneData_setCSMSupported) + +static bool js_cc_pipeline_PipelineSceneData_isHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_isHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_isHDR_set) + +static bool js_cc_pipeline_PipelineSceneData_isHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_PipelineSceneData_isHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_PipelineSceneData_isHDR_get) + +static bool js_cc_pipeline_PipelineSceneData_shadingScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_shadingScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_shadingScale_set) + +static bool js_cc_pipeline_PipelineSceneData_shadingScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_pipeline_PipelineSceneData_shadingScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_PipelineSceneData_shadingScale_get) + +static bool js_cc_pipeline_PipelineSceneData_fog_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Fog *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Fog *)cc_pipeline_PipelineSceneData_fog_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_pipeline_PipelineSceneData_fog_get) + +static bool js_cc_pipeline_PipelineSceneData_ambient_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Ambient *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Ambient *)cc_pipeline_PipelineSceneData_ambient_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_pipeline_PipelineSceneData_ambient_get) + +static bool js_cc_pipeline_PipelineSceneData_skybox_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Skybox *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Skybox *)cc_pipeline_PipelineSceneData_skybox_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_pipeline_PipelineSceneData_skybox_get) + +static bool js_cc_pipeline_PipelineSceneData_shadows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Shadows *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Shadows *)cc_pipeline_PipelineSceneData_shadows_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_pipeline_PipelineSceneData_shadows_get) + +static bool js_cc_pipeline_PipelineSceneData_skin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Skin *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Skin *)cc_pipeline_PipelineSceneData_skin_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_pipeline_PipelineSceneData_skin_get) + +static bool js_cc_pipeline_PipelineSceneData_postSettings_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::PostSettings *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::PostSettings *)cc_pipeline_PipelineSceneData_postSettings_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_pipeline_PipelineSceneData_postSettings_get) + +static bool js_cc_pipeline_PipelineSceneData_lightProbes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::gi::LightProbes *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbes *)cc_pipeline_PipelineSceneData_lightProbes_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_pipeline_PipelineSceneData_lightProbes_get) + +static bool js_cc_pipeline_PipelineSceneData_validPunctualLights_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::scene::Light const * > arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_pipeline_PipelineSceneData_validPunctualLights_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_validPunctualLights_set) + +static bool js_cc_pipeline_PipelineSceneData_validPunctualLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + ccstd::vector< cc::scene::Light const * > result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_pipeline_PipelineSceneData_validPunctualLights_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_pipeline_PipelineSceneData_validPunctualLights_get) + +static bool js_cc_pipeline_PipelineSceneData_csmSupported_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_pipeline_PipelineSceneData_csmSupported_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_pipeline_PipelineSceneData_csmSupported_get) + +static bool js_cc_pipeline_PipelineSceneData_standardSkinModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_standardSkinModel_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_standardSkinModel_set) + +static bool js_cc_pipeline_PipelineSceneData_standardSkinModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_pipeline_PipelineSceneData_standardSkinModel_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_pipeline_PipelineSceneData_standardSkinModel_get) + +static bool js_cc_pipeline_PipelineSceneData_skinMaterialModel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_pipeline_PipelineSceneData_skinMaterialModel_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_pipeline_PipelineSceneData_skinMaterialModel_set) + +static bool js_cc_pipeline_PipelineSceneData_skinMaterialModel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::pipeline::PipelineSceneData *arg1 = (cc::pipeline::PipelineSceneData *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_pipeline_PipelineSceneData_skinMaterialModel_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_pipeline_PipelineSceneData_skinMaterialModel_get) + +bool js_register_cc_pipeline_PipelineSceneData(se::Object* obj) { + auto* cls = se::Class::create("PipelineSceneData", obj, nullptr, _SE(js_new_cc_pipeline_PipelineSceneData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("isHDR", _SE(js_cc_pipeline_PipelineSceneData_isHDR_get), _SE(js_cc_pipeline_PipelineSceneData_isHDR_set)); + cls->defineProperty("shadingScale", _SE(js_cc_pipeline_PipelineSceneData_shadingScale_get), _SE(js_cc_pipeline_PipelineSceneData_shadingScale_set)); + cls->defineProperty("fog", _SE(js_cc_pipeline_PipelineSceneData_fog_get), nullptr); + cls->defineProperty("ambient", _SE(js_cc_pipeline_PipelineSceneData_ambient_get), nullptr); + cls->defineProperty("skybox", _SE(js_cc_pipeline_PipelineSceneData_skybox_get), nullptr); + cls->defineProperty("shadows", _SE(js_cc_pipeline_PipelineSceneData_shadows_get), nullptr); + cls->defineProperty("skin", _SE(js_cc_pipeline_PipelineSceneData_skin_get), nullptr); + cls->defineProperty("postSettings", _SE(js_cc_pipeline_PipelineSceneData_postSettings_get), nullptr); + cls->defineProperty("lightProbes", _SE(js_cc_pipeline_PipelineSceneData_lightProbes_get), nullptr); + cls->defineProperty("validPunctualLights", _SE(js_cc_pipeline_PipelineSceneData_validPunctualLights_get), _SE(js_cc_pipeline_PipelineSceneData_validPunctualLights_set)); + cls->defineProperty("csmSupported", _SE(js_cc_pipeline_PipelineSceneData_csmSupported_get), nullptr); + cls->defineProperty("standardSkinModel", _SE(js_cc_pipeline_PipelineSceneData_standardSkinModel_get), _SE(js_cc_pipeline_PipelineSceneData_standardSkinModel_set)); + cls->defineProperty("skinMaterialModel", _SE(js_cc_pipeline_PipelineSceneData_skinMaterialModel_get), _SE(js_cc_pipeline_PipelineSceneData_skinMaterialModel_set)); + + cls->defineFunction("activate", _SE(js_cc_pipeline_PipelineSceneData_activate)); + cls->defineFunction("destroy", _SE(js_cc_pipeline_PipelineSceneData_destroy)); + cls->defineFunction("updatePipelineSceneData", _SE(js_cc_pipeline_PipelineSceneData_updatePipelineSceneData)); + cls->defineFunction("setShadowFramebuffer", _SE(js_cc_pipeline_PipelineSceneData_setShadowFramebuffer)); + cls->defineFunction("getOctree", _SE(js_cc_pipeline_PipelineSceneData_getOctree)); + cls->defineFunction("getOcclusionQueryInputAssembler", _SE(js_cc_pipeline_PipelineSceneData_getOcclusionQueryInputAssembler)); + cls->defineFunction("getOcclusionQueryPass", _SE(js_cc_pipeline_PipelineSceneData_getOcclusionQueryPass)); + cls->defineFunction("getOcclusionQueryShader", _SE(js_cc_pipeline_PipelineSceneData_getOcclusionQueryShader)); + cls->defineFunction("getGeometryRendererMaterials", _SE(js_cc_pipeline_PipelineSceneData_getGeometryRendererMaterials)); + cls->defineFunction("getGeometryRendererPasses", _SE(js_cc_pipeline_PipelineSceneData_getGeometryRendererPasses)); + cls->defineFunction("getGeometryRendererShaders", _SE(js_cc_pipeline_PipelineSceneData_getGeometryRendererShaders)); + cls->defineFunction("getDebugRendererPass", _SE(js_cc_pipeline_PipelineSceneData_getDebugRendererPass)); + cls->defineFunction("getDebugRendererShader", _SE(js_cc_pipeline_PipelineSceneData_getDebugRendererShader)); + cls->defineFunction("addRenderObject", _SE(js_cc_pipeline_PipelineSceneData_addRenderObject)); + cls->defineFunction("clearRenderObjects", _SE(js_cc_pipeline_PipelineSceneData_clearRenderObjects)); + cls->defineFunction("addValidPunctualLight", _SE(js_cc_pipeline_PipelineSceneData_addValidPunctualLight)); + cls->defineFunction("clearValidPunctualLights", _SE(js_cc_pipeline_PipelineSceneData_clearValidPunctualLights)); + cls->defineFunction("setCSMSupported", _SE(js_cc_pipeline_PipelineSceneData_setCSMSupported)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_PipelineSceneData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_PipelineSceneData_proto = cls->getProto(); + __jsb_cc_pipeline_PipelineSceneData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#if CC_USE_GEOMETRY_RENDERER + +se::Class* __jsb_cc_pipeline_GeometryRenderer_class = nullptr; +se::Object* __jsb_cc_pipeline_GeometryRenderer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_GeometryRenderer) + +static bool js_new_cc_pipeline_GeometryRenderer(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::GeometryRenderer *result; + result = (cc::pipeline::GeometryRenderer *)new cc::pipeline::GeometryRenderer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_GeometryRenderer, __jsb_cc_pipeline_GeometryRenderer_class, js_delete_cc_pipeline_GeometryRenderer) + +static bool js_delete_cc_pipeline_GeometryRenderer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_GeometryRenderer) + +static bool js_cc_pipeline_GeometryRenderer_empty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::pipeline::GeometryRenderer const *)arg1)->empty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_empty) + +static bool js_cc_pipeline_GeometryRenderer_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_update) + +static bool js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDashedLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDashedLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDashedLine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addDashedLine__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addDashedLine) + +static bool js_cc_pipeline_GeometryRenderer_addLine__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addLine__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addLine((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addLine(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addLine__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addLine__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addLine) + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTriangle((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTriangle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addTriangle__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addTriangle) + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addQuad((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addQuad(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addQuad__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addQuad) + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + cc::Mat4 *arg8 = 0 ; + cc::geometry::AABB temp2 ; + cc::Mat4 temp8 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5,arg6,arg7,(cc::Mat4 const &)*arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + bool arg5 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::AABB *arg2 = 0 ; + cc::gfx::Color arg3 ; + cc::geometry::AABB temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addBoundingBox((cc::geometry::AABB const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_GeometryRenderer_addBoundingBox__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addBoundingBox) + +static bool js_cc_pipeline_GeometryRenderer_addCross__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCross((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCross__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCross((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCross(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCross__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addCross__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCross) + +static bool js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::gfx::Color arg3 ; + bool arg4 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addFrustum((cc::geometry::Frustum const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::gfx::Color arg3 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addFrustum((cc::geometry::Frustum const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_GeometryRenderer_addFrustum__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addFrustum) + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Mat4 *arg12 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp12 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &temp12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg12 = &temp12; + + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(cc::Mat4 const &)*arg12); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCapsule((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCapsule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 11) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCapsule__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCapsule) + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Mat4 *arg11 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp11 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &temp11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg11 = &temp11; + + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(cc::Mat4 const &)*arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCylinder((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCylinder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCylinder__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCylinder) + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Mat4 *arg11 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp11 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &temp11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg11 = &temp11; + + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(cc::Mat4 const &)*arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCone((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCone__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCone) + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Mat4 *arg8 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp8 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,(cc::Mat4 const &)*arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addCircle((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addCircle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addCircle__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addCircle) + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addArc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addArc(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addArc__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addArc) + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addPolygon((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addPolygon__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addPolygon) + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addDisc((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addDisc(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addDisc__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addDisc) + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Mat4 *arg12 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp12 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &temp12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg12 = &temp12; + + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(cc::Mat4 const &)*arg12); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + float arg5 ; + float arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSector((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSector(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 11) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addSector__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addSector) + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Mat4 *arg11 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp11 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &temp11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg11 = &temp11; + + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(cc::Mat4 const &)*arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + uint32_t arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSphere((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSphere(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addSphere__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addSphere) + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Mat4 *arg12 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp12 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[10], &temp12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg12 = &temp12; + + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(cc::Mat4 const &)*arg12); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[9], &arg11); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + uint32_t arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + float arg4 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addTorus((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addTorus(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 11) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 10) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addTorus__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addTorus) + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Mat4 *arg9 = 0 ; + cc::Vec3 temp2 ; + cc::Mat4 temp9 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &temp9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg9 = &temp9; + + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(cc::Mat4 const &)*arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addOctahedron((cc::Vec3 const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addOctahedron(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addOctahedron__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addOctahedron) + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Mat4 *arg10 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + cc::Mat4 temp10 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &temp10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg10 = &temp10; + + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8,arg9,(cc::Mat4 const &)*arg10); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + bool arg8 ; + bool arg9 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + bool arg8 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + uint32_t arg7 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 *arg4 = 0 ; + cc::Vec3 *arg5 = 0 ; + cc::gfx::Color arg6 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + cc::Vec3 temp4 ; + cc::Vec3 temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addBezier((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,(cc::Vec3 const &)*arg4,(cc::Vec3 const &)*arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addBezier(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addBezier__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addBezier) + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::Mat4 *arg9 = 0 ; + cc::geometry::Spline temp2 ; + cc::Mat4 temp9 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &temp9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg9 = &temp9; + + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,(cc::Mat4 const &)*arg9); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + bool arg7 ; + bool arg8 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + bool arg7 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + uint32_t arg6 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + float arg5 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + uint32_t arg4 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSpline((cc::geometry::Spline const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::geometry::Spline *arg2 = 0 ; + cc::gfx::Color arg3 ; + cc::geometry::Spline temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addSpline((cc::geometry::Spline const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addSpline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 8) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_pipeline_GeometryRenderer_addSpline__SWIG_6(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addSpline) + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + cc::Mat4 *arg7 = 0 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + cc::Mat4 temp7 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4,arg5,arg6,(cc::Mat4 const &)*arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + bool arg5 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + cc::gfx::Color arg4 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_pipeline_GeometryRenderer_addMesh__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addMesh) + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + cc::Mat4 *arg8 = 0 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + cc::Mat4 temp8 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &temp8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg8 = &temp8; + + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5,arg6,arg7,(cc::Mat4 const &)*arg8); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + bool arg7 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + bool arg6 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::pipeline::GeometryRenderer *arg1 = (cc::pipeline::GeometryRenderer *) NULL ; + cc::Vec3 *arg2 = 0 ; + ccstd::vector< cc::Vec3 > *arg3 = 0 ; + ccstd::vector< uint32_t > *arg4 = 0 ; + cc::gfx::Color arg5 ; + cc::Vec3 temp2 ; + ccstd::vector< cc::Vec3 > temp3 ; + ccstd::vector< uint32_t > temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addIndexedMesh((cc::Vec3 const &)*arg2,(ccstd::vector< cc::Vec3 > const &)*arg3,(ccstd::vector< uint32_t > const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_pipeline_GeometryRenderer_addIndexedMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 7) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_pipeline_GeometryRenderer_addIndexedMesh__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_pipeline_GeometryRenderer_addIndexedMesh) + +bool js_register_cc_pipeline_GeometryRenderer(se::Object* obj) { + auto* cls = se::Class::create("GeometryRenderer", obj, nullptr, _SE(js_new_cc_pipeline_GeometryRenderer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("empty", _SE(js_cc_pipeline_GeometryRenderer_empty)); + cls->defineFunction("update", _SE(js_cc_pipeline_GeometryRenderer_update)); + cls->defineFunction("addDashedLine", _SE(js_cc_pipeline_GeometryRenderer_addDashedLine)); + cls->defineFunction("addLine", _SE(js_cc_pipeline_GeometryRenderer_addLine)); + cls->defineFunction("addTriangle", _SE(js_cc_pipeline_GeometryRenderer_addTriangle)); + cls->defineFunction("addQuad", _SE(js_cc_pipeline_GeometryRenderer_addQuad)); + cls->defineFunction("addBoundingBox", _SE(js_cc_pipeline_GeometryRenderer_addBoundingBox)); + cls->defineFunction("addCross", _SE(js_cc_pipeline_GeometryRenderer_addCross)); + cls->defineFunction("addFrustum", _SE(js_cc_pipeline_GeometryRenderer_addFrustum)); + cls->defineFunction("addCapsule", _SE(js_cc_pipeline_GeometryRenderer_addCapsule)); + cls->defineFunction("addCylinder", _SE(js_cc_pipeline_GeometryRenderer_addCylinder)); + cls->defineFunction("addCone", _SE(js_cc_pipeline_GeometryRenderer_addCone)); + cls->defineFunction("addCircle", _SE(js_cc_pipeline_GeometryRenderer_addCircle)); + cls->defineFunction("addArc", _SE(js_cc_pipeline_GeometryRenderer_addArc)); + cls->defineFunction("addPolygon", _SE(js_cc_pipeline_GeometryRenderer_addPolygon)); + cls->defineFunction("addDisc", _SE(js_cc_pipeline_GeometryRenderer_addDisc)); + cls->defineFunction("addSector", _SE(js_cc_pipeline_GeometryRenderer_addSector)); + cls->defineFunction("addSphere", _SE(js_cc_pipeline_GeometryRenderer_addSphere)); + cls->defineFunction("addTorus", _SE(js_cc_pipeline_GeometryRenderer_addTorus)); + cls->defineFunction("addOctahedron", _SE(js_cc_pipeline_GeometryRenderer_addOctahedron)); + cls->defineFunction("addBezier", _SE(js_cc_pipeline_GeometryRenderer_addBezier)); + cls->defineFunction("addSpline", _SE(js_cc_pipeline_GeometryRenderer_addSpline)); + cls->defineFunction("addMesh", _SE(js_cc_pipeline_GeometryRenderer_addMesh)); + cls->defineFunction("addIndexedMesh", _SE(js_cc_pipeline_GeometryRenderer_addIndexedMesh)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_GeometryRenderer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_GeometryRenderer_proto = cls->getProto(); + __jsb_cc_pipeline_GeometryRenderer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + +#endif // CC_USE_GEOMETRY_RENDERER + +se::Class* __jsb_cc_pipeline_ReflectionProbeFlow_class = nullptr; +se::Object* __jsb_cc_pipeline_ReflectionProbeFlow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeFlow) + +static bool js_new_cc_pipeline_ReflectionProbeFlow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ReflectionProbeFlow *result; + result = (cc::pipeline::ReflectionProbeFlow *)new cc::pipeline::ReflectionProbeFlow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ReflectionProbeFlow, __jsb_cc_pipeline_ReflectionProbeFlow_class, js_delete_cc_pipeline_ReflectionProbeFlow) + +static bool js_delete_cc_pipeline_ReflectionProbeFlow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeFlow) + +static bool js_cc_pipeline_ReflectionProbeFlow_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderFlowInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderFlowInfo *) &cc::pipeline::ReflectionProbeFlow::getInitializeInfo(); + + 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_pipeline_ReflectionProbeFlow_getInitializeInfo_static) + +bool js_register_cc_pipeline_ReflectionProbeFlow(se::Object* obj) { + auto* cls = se::Class::create("ReflectionProbeFlow", obj, __jsb_cc_pipeline_RenderFlow_proto, _SE(js_new_cc_pipeline_ReflectionProbeFlow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ReflectionProbeFlow_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ReflectionProbeFlow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ReflectionProbeFlow_proto = cls->getProto(); + __jsb_cc_pipeline_ReflectionProbeFlow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_pipeline_ReflectionProbeStage_class = nullptr; +se::Object* __jsb_cc_pipeline_ReflectionProbeStage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeStage) + +static bool js_new_cc_pipeline_ReflectionProbeStage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::pipeline::ReflectionProbeStage *result; + result = (cc::pipeline::ReflectionProbeStage *)new cc::pipeline::ReflectionProbeStage(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_pipeline_ReflectionProbeStage, __jsb_cc_pipeline_ReflectionProbeStage_class, js_delete_cc_pipeline_ReflectionProbeStage) + +static bool js_delete_cc_pipeline_ReflectionProbeStage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_pipeline_ReflectionProbeStage) + +static bool js_cc_pipeline_ReflectionProbeStage_getInitializeInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::RenderStageInfo *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::pipeline::RenderStageInfo *) &cc::pipeline::ReflectionProbeStage::getInitializeInfo(); + + 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_pipeline_ReflectionProbeStage_getInitializeInfo_static) + +static bool js_cc_pipeline_ReflectionProbeStage_setFramebuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ReflectionProbeStage *arg1 = (cc::pipeline::ReflectionProbeStage *) NULL ; + cc::gfx::Framebuffer *arg2 = (cc::gfx::Framebuffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFramebuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ReflectionProbeStage_setFramebuffer) + +static bool js_cc_pipeline_ReflectionProbeStage_setUsage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::pipeline::ReflectionProbeStage *arg1 = (cc::pipeline::ReflectionProbeStage *) NULL ; + cc::gfx::Framebuffer *arg2 = (cc::gfx::Framebuffer *) NULL ; + cc::scene::ReflectionProbe *arg3 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setUsage(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_pipeline_ReflectionProbeStage_setUsage) + +bool js_register_cc_pipeline_ReflectionProbeStage(se::Object* obj) { + auto* cls = se::Class::create("ReflectionProbeStage", obj, __jsb_cc_pipeline_RenderStage_proto, _SE(js_new_cc_pipeline_ReflectionProbeStage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFramebuffer", _SE(js_cc_pipeline_ReflectionProbeStage_setFramebuffer)); + cls->defineFunction("setUsage", _SE(js_cc_pipeline_ReflectionProbeStage_setUsage)); + + + cls->defineStaticFunction("getInitializeInfo", _SE(js_cc_pipeline_ReflectionProbeStage_getInitializeInfo_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_pipeline_ReflectionProbeStage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_pipeline_ReflectionProbeStage_proto = cls->getProto(); + __jsb_cc_pipeline_ReflectionProbeStage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_pipeline(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("nr", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("nr", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_pipeline_SkinningJointCapacity(ns); + js_register_cc_pipeline_RenderObject(ns); + js_register_cc_pipeline_RenderTargetInfo(ns); + js_register_cc_pipeline_RenderPass(ns); + js_register_cc_pipeline_RenderPassDesc(ns); + js_register_cc_pipeline_RenderTextureDesc(ns); + js_register_cc_pipeline_FrameBufferDesc(ns); + js_register_cc_pipeline_InternalBindingDesc(ns); + js_register_cc_pipeline_InternalBindingInst(ns); + js_register_cc_pipeline_RenderQueueCreateInfo(ns); + js_register_cc_pipeline_RenderQueueDesc(ns); + js_register_cc_pipeline_UBOLocalBatched(ns); + js_register_cc_pipeline_UBOLocal(ns); + js_register_cc_pipeline_UBOWorldBound(ns); + js_register_cc_pipeline_UBOForwardLight(ns); + js_register_cc_pipeline_UBODeferredLight(ns); + js_register_cc_pipeline_UBOSkinningTexture(ns); + js_register_cc_pipeline_UBOSkinningAnimation(ns); + js_register_cc_pipeline_UBOSkinning(ns); + js_register_cc_pipeline_UBOMorph(ns); + js_register_cc_pipeline_UBOUILocal(ns); + js_register_cc_pipeline_UBOSH(ns); + js_register_cc_pipeline_UBOGlobal(ns); + js_register_cc_pipeline_UBOCamera(ns); + js_register_cc_pipeline_UBOShadow(ns); + js_register_cc_pipeline_UBOCSM(ns); + js_register_cc_pipeline_DescriptorSetLayoutInfos(ns); + js_register_cc_pipeline_SHADOWMAP(ns); + js_register_cc_pipeline_ENVIRONMENT(ns); + js_register_cc_pipeline_SPOTSHADOWMAP(ns); + js_register_cc_pipeline_DIFFUSEMAP(ns); + js_register_cc_pipeline_JOINTTEXTURE(ns); + js_register_cc_pipeline_REALTIMEJOINTTEXTURE(ns); + js_register_cc_pipeline_POSITIONMORPH(ns); + js_register_cc_pipeline_NORMALMORPH(ns); + js_register_cc_pipeline_TANGENTMORPH(ns); + js_register_cc_pipeline_LIGHTMAPTEXTURE(ns); + js_register_cc_pipeline_SPRITETEXTURE(ns); + js_register_cc_pipeline_REFLECTIONPROBECUBEMAP(ns); + js_register_cc_pipeline_REFLECTIONPROBEPLANARMAP(ns); + js_register_cc_pipeline_REFLECTIONPROBEDATAMAP(ns); + js_register_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP(ns); + js_register_cc_pipeline_RenderPipelineInfo(ns); + js_register_cc_pipeline_RenderPipeline(ns); + js_register_cc_pipeline_RenderFlowInfo(ns); + js_register_cc_pipeline_RenderFlow(ns); + js_register_cc_pipeline_RenderStageInfo(ns); + js_register_cc_pipeline_RenderStage(ns); + js_register_cc_pipeline_DebugView(ns); + js_register_cc_pipeline_ForwardPipeline(ns); + js_register_cc_pipeline_ForwardFlow(ns); + js_register_cc_pipeline_ForwardStage(ns); + js_register_cc_pipeline_ShadowFlow(ns); + js_register_cc_pipeline_ShadowStage(ns); + js_register_cc_pipeline_ShadowTransformInfo(ns); + js_register_cc_pipeline_CSMLayerInfo(ns); + js_register_cc_pipeline_CSMLayers(ns); + js_register_cc_pipeline_GlobalDSManager(ns); + js_register_cc_pipeline_InstancedItem(ns); + js_register_cc_pipeline_InstancedBuffer(ns); + js_register_cc_pipeline_DeferredPipeline(ns); + js_register_cc_pipeline_MainFlow(ns); + js_register_cc_pipeline_GbufferStage(ns); + js_register_cc_pipeline_RenderElem(ns); + js_register_cc_pipeline_LightingStage(ns); + js_register_cc_pipeline_BloomStage(ns); + js_register_cc_pipeline_PostProcessStage(ns); + js_register_cc_pipeline_PipelineSceneData(ns); +#if CC_USE_GEOMETRY_RENDERER + js_register_cc_pipeline_GeometryRenderer(ns); +#endif // CC_USE_GEOMETRY_RENDERER + js_register_cc_pipeline_ReflectionProbeFlow(ns); + js_register_cc_pipeline_ReflectionProbeStage(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_pipeline_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_pipeline_auto.h new file mode 100644 index 0000000000..352b322a26 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_pipeline_auto.h @@ -0,0 +1,599 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "renderer/pipeline/forward/ForwardPipeline.h" +#include "renderer/pipeline/forward/ForwardFlow.h" +#include "renderer/pipeline/forward/ForwardStage.h" +#include "renderer/pipeline/shadow/ShadowFlow.h" +#include "renderer/pipeline/shadow/ShadowStage.h" +#include "renderer/pipeline/shadow/CSMLayers.h" +#include "renderer/pipeline/GlobalDescriptorSetManager.h" +#include "renderer/pipeline/InstancedBuffer.h" +#include "renderer/pipeline/deferred/DeferredPipeline.h" +#include "renderer/pipeline/deferred/MainFlow.h" +#include "renderer/pipeline/deferred/GbufferStage.h" +#include "renderer/pipeline/deferred/LightingStage.h" +#include "renderer/pipeline/deferred/BloomStage.h" +#include "renderer/pipeline/deferred/PostProcessStage.h" +#include "renderer/pipeline/PipelineSceneData.h" +#include "renderer/pipeline/GeometryRenderer.h" +#include "renderer/pipeline/DebugView.h" +#include "renderer/pipeline/reflection-probe/ReflectionProbeFlow.h" +#include "renderer/pipeline/reflection-probe/ReflectionProbeStage.h" + + + +bool register_all_pipeline(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SkinningJointCapacity); +extern se::Object *__jsb_cc_pipeline_SkinningJointCapacity_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SkinningJointCapacity_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderObject); +extern se::Object *__jsb_cc_pipeline_RenderObject_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderObject_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderObject * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderTargetInfo); +extern se::Object *__jsb_cc_pipeline_RenderTargetInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderTargetInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTargetInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPass); +extern se::Object *__jsb_cc_pipeline_RenderPass_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPass_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPass * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPassDesc); +extern se::Object *__jsb_cc_pipeline_RenderPassDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPassDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPassDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderTextureDesc); +extern se::Object *__jsb_cc_pipeline_RenderTextureDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderTextureDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderTextureDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::FrameBufferDesc); +extern se::Object *__jsb_cc_pipeline_FrameBufferDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_FrameBufferDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::FrameBufferDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InternalBindingDesc); +extern se::Object *__jsb_cc_pipeline_InternalBindingDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InternalBindingDesc_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingDesc * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InternalBindingInst); +extern se::Object *__jsb_cc_pipeline_InternalBindingInst_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InternalBindingInst_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InternalBindingInst * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderQueueCreateInfo); +extern se::Object *__jsb_cc_pipeline_RenderQueueCreateInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderQueueCreateInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderQueueCreateInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderQueueDesc); +extern se::Object *__jsb_cc_pipeline_RenderQueueDesc_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderQueueDesc_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOLocalBatched); +extern se::Object *__jsb_cc_pipeline_UBOLocalBatched_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOLocalBatched_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocalBatched * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOLocal); +extern se::Object *__jsb_cc_pipeline_UBOLocal_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOLocal_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOLocal * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOWorldBound); +extern se::Object *__jsb_cc_pipeline_UBOWorldBound_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOWorldBound_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOWorldBound * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOForwardLight); +extern se::Object *__jsb_cc_pipeline_UBOForwardLight_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOForwardLight_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOForwardLight * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBODeferredLight); +extern se::Object *__jsb_cc_pipeline_UBODeferredLight_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBODeferredLight_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBODeferredLight * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSkinningTexture); +extern se::Object *__jsb_cc_pipeline_UBOSkinningTexture_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSkinningTexture_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningTexture * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSkinningAnimation); +extern se::Object *__jsb_cc_pipeline_UBOSkinningAnimation_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSkinningAnimation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinningAnimation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSkinning); +extern se::Object *__jsb_cc_pipeline_UBOSkinning_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSkinning_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSkinning * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOMorph); +extern se::Object *__jsb_cc_pipeline_UBOMorph_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOMorph_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOMorph * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOUILocal); +extern se::Object *__jsb_cc_pipeline_UBOUILocal_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOUILocal_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOUILocal * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOSH); +extern se::Object *__jsb_cc_pipeline_UBOSH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOSH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOSH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOGlobal); +extern se::Object *__jsb_cc_pipeline_UBOGlobal_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOGlobal_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOGlobal * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOCamera); +extern se::Object *__jsb_cc_pipeline_UBOCamera_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOCamera_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCamera * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOShadow); +extern se::Object *__jsb_cc_pipeline_UBOShadow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOShadow_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOShadow * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::UBOCSM); +extern se::Object *__jsb_cc_pipeline_UBOCSM_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_UBOCSM_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::UBOCSM * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DescriptorSetLayoutInfos); +extern se::Object *__jsb_cc_pipeline_DescriptorSetLayoutInfos_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DescriptorSetLayoutInfos_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DescriptorSetLayoutInfos * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SHADOWMAP); +extern se::Object *__jsb_cc_pipeline_SHADOWMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SHADOWMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SHADOWMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ENVIRONMENT); +extern se::Object *__jsb_cc_pipeline_ENVIRONMENT_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ENVIRONMENT_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::ENVIRONMENT * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SPOTSHADOWMAP); +extern se::Object *__jsb_cc_pipeline_SPOTSHADOWMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SPOTSHADOWMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPOTSHADOWMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DIFFUSEMAP); +extern se::Object *__jsb_cc_pipeline_DIFFUSEMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DIFFUSEMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::DIFFUSEMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::JOINTTEXTURE); +extern se::Object *__jsb_cc_pipeline_JOINTTEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_JOINTTEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::JOINTTEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REALTIMEJOINTTEXTURE); +extern se::Object *__jsb_cc_pipeline_REALTIMEJOINTTEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REALTIMEJOINTTEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REALTIMEJOINTTEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::POSITIONMORPH); +extern se::Object *__jsb_cc_pipeline_POSITIONMORPH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_POSITIONMORPH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::POSITIONMORPH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::NORMALMORPH); +extern se::Object *__jsb_cc_pipeline_NORMALMORPH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_NORMALMORPH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::NORMALMORPH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::TANGENTMORPH); +extern se::Object *__jsb_cc_pipeline_TANGENTMORPH_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_TANGENTMORPH_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::TANGENTMORPH * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::LIGHTMAPTEXTURE); +extern se::Object *__jsb_cc_pipeline_LIGHTMAPTEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_LIGHTMAPTEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::LIGHTMAPTEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::SPRITETEXTURE); +extern se::Object *__jsb_cc_pipeline_SPRITETEXTURE_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_SPRITETEXTURE_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::SPRITETEXTURE * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBECUBEMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBECUBEMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBECUBEMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBEPLANARMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBEPLANARMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEPLANARMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBEDATAMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBEDATAMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEDATAMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP); +extern se::Object *__jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_REFLECTIONPROBEBLENDCUBEMAP_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::REFLECTIONPROBEBLENDCUBEMAP * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPipelineInfo); +extern se::Object *__jsb_cc_pipeline_RenderPipelineInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPipelineInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderPipelineInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderPipeline); +extern se::Object *__jsb_cc_pipeline_RenderPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderFlowInfo); +extern se::Object *__jsb_cc_pipeline_RenderFlowInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderFlowInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderFlowInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderFlow); +extern se::Object *__jsb_cc_pipeline_RenderFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderStageInfo); +extern se::Object *__jsb_cc_pipeline_RenderStageInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderStageInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderStageInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderStage); +extern se::Object *__jsb_cc_pipeline_RenderStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DebugView); +extern se::Object *__jsb_cc_pipeline_DebugView_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DebugView_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ForwardPipeline); +extern se::Object *__jsb_cc_pipeline_ForwardPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ForwardPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ForwardFlow); +extern se::Object *__jsb_cc_pipeline_ForwardFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ForwardFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ForwardStage); +extern se::Object *__jsb_cc_pipeline_ForwardStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ForwardStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ShadowFlow); +extern se::Object *__jsb_cc_pipeline_ShadowFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ShadowFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ShadowStage); +extern se::Object *__jsb_cc_pipeline_ShadowStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ShadowStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ShadowTransformInfo); +extern se::Object *__jsb_cc_pipeline_ShadowTransformInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ShadowTransformInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::CSMLayerInfo); +extern se::Object *__jsb_cc_pipeline_CSMLayerInfo_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_CSMLayerInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::CSMLayers); +extern se::Object *__jsb_cc_pipeline_CSMLayers_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_CSMLayers_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::GlobalDSManager); +extern se::Object *__jsb_cc_pipeline_GlobalDSManager_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_GlobalDSManager_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InstancedItem); +extern se::Object *__jsb_cc_pipeline_InstancedItem_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InstancedItem_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::InstancedItem * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::InstancedBuffer); +extern se::Object *__jsb_cc_pipeline_InstancedBuffer_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_InstancedBuffer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::DeferredPipeline); +extern se::Object *__jsb_cc_pipeline_DeferredPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_DeferredPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::MainFlow); +extern se::Object *__jsb_cc_pipeline_MainFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_MainFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::GbufferStage); +extern se::Object *__jsb_cc_pipeline_GbufferStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_GbufferStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::RenderElem); +extern se::Object *__jsb_cc_pipeline_RenderElem_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_RenderElem_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::pipeline::RenderElem * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::LightingStage); +extern se::Object *__jsb_cc_pipeline_LightingStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_LightingStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::BloomStage); +extern se::Object *__jsb_cc_pipeline_BloomStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_BloomStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::PostProcessStage); +extern se::Object *__jsb_cc_pipeline_PostProcessStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_PostProcessStage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::PipelineSceneData); +extern se::Object *__jsb_cc_pipeline_PipelineSceneData_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_PipelineSceneData_class; // NOLINT + +#if CC_USE_GEOMETRY_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::GeometryRenderer); +extern se::Object *__jsb_cc_pipeline_GeometryRenderer_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_GeometryRenderer_class; // NOLINT + +#endif // CC_USE_GEOMETRY_RENDERER + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ReflectionProbeFlow); +extern se::Object *__jsb_cc_pipeline_ReflectionProbeFlow_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ReflectionProbeFlow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::pipeline::ReflectionProbeStage); +extern se::Object *__jsb_cc_pipeline_ReflectionProbeStage_proto; // NOLINT +extern se::Class * __jsb_cc_pipeline_ReflectionProbeStage_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_render_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_render_auto.cpp new file mode 100644 index 0000000000..dafc2887a6 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_render_auto.cpp @@ -0,0 +1,9824 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_render_auto.h" +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "renderer/pipeline/GeometryRenderer.h" +#include "renderer/pipeline/GlobalDescriptorSetManager.h" +#include "renderer/pipeline/custom/RenderCommonJsb.h" + +using namespace cc; +using namespace cc::render; + + +#define cc_render_PipelineRuntime_device_get(self_) self_->getDevice() + + +#define cc_render_PipelineRuntime_macros_get(self_) self_->getMacros() + + +#define cc_render_PipelineRuntime_globalDSManager_get(self_) self_->getGlobalDSManager() + + +#define cc_render_PipelineRuntime_descriptorSetLayout_get(self_) self_->getDescriptorSetLayout() + + +#define cc_render_PipelineRuntime_descriptorSet_get(self_) self_->getDescriptorSet() + + +#define cc_render_PipelineRuntime_commandBuffers_get(self_) self_->getCommandBuffers() + + +#define cc_render_PipelineRuntime_pipelineSceneData_get(self_) self_->getPipelineSceneData() + + +#define cc_render_PipelineRuntime_constantMacros_get(self_) self_->getConstantMacros() + + +#define cc_render_PipelineRuntime_profiler_get(self_) self_->getProfiler() +#define cc_render_PipelineRuntime_profiler_set(self_, val_) self_->setProfiler(val_) + + +#define cc_render_PipelineRuntime_geometryRenderer_get(self_) self_->getGeometryRenderer() + + +#define cc_render_PipelineRuntime_shadingScale_get(self_) self_->getShadingScale() +#define cc_render_PipelineRuntime_shadingScale_set(self_, val_) self_->setShadingScale(val_) + + +#define cc_render_RenderNode_name_get(self_) self_->getName() +#define cc_render_RenderNode_name_set(self_, val_) self_->setName(val_) + + +#define cc_render_BasicRenderPassBuilder_showStatistics_get(self_) self_->getShowStatistics() +#define cc_render_BasicRenderPassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_) + + +#define cc_render_BasicPipeline_type_get(self_) self_->getType() + + +#define cc_render_BasicPipeline_capabilities_get(self_) self_->getCapabilities() + + +#define cc_render_BasicPipeline_enableCpuLightCulling_get(self_) self_->getEnableCpuLightCulling() +#define cc_render_BasicPipeline_enableCpuLightCulling_set(self_, val_) self_->setEnableCpuLightCulling(val_) + + +#define cc_render_RenderSubpassBuilder_showStatistics_get(self_) self_->getShowStatistics() +#define cc_render_RenderSubpassBuilder_showStatistics_set(self_, val_) self_->setShowStatistics(val_) + + + +se::Class* __jsb_cc_render_PipelineRuntime_class = nullptr; +se::Object* __jsb_cc_render_PipelineRuntime_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineRuntime) + +static bool js_delete_cc_render_PipelineRuntime(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelineRuntime) + +static bool js_cc_render_PipelineRuntime_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineRuntime *arg1 = (cc::render::PipelineRuntime *) NULL ; + gfx::Swapchain *arg2 = (gfx::Swapchain *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(cls); + + __jsb_cc_render_PipelineRuntime_proto = cls->getProto(); + __jsb_cc_render_PipelineRuntime_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_render_any(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::SubpassCapabilities arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::render::any(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_any) + +se::Class* __jsb_cc_render_PipelineCapabilities_class = nullptr; +se::Object* __jsb_cc_render_PipelineCapabilities_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineCapabilities) + +static bool js_cc_render_PipelineCapabilities_subpass_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineCapabilities *arg1 = (cc::render::PipelineCapabilities *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subpass, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_PipelineCapabilities_subpass_set) + +static bool js_cc_render_PipelineCapabilities_subpass_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::PipelineCapabilities *arg1 = (cc::render::PipelineCapabilities *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subpass, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->subpass, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_PipelineCapabilities_subpass_get) + +static bool js_new_cc_render_PipelineCapabilities(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::render::PipelineCapabilities *result; + result = (cc::render::PipelineCapabilities *)new cc::render::PipelineCapabilities(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_render_PipelineCapabilities, __jsb_cc_render_PipelineCapabilities_class, js_delete_cc_render_PipelineCapabilities) + +static bool js_delete_cc_render_PipelineCapabilities(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelineCapabilities) + +template<> +bool sevalue_to_native(const se::Value &from, cc::render::PipelineCapabilities * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("subpass", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subpass), ctx); + } + + + return ok; +} + + +bool js_register_cc_render_PipelineCapabilities(se::Object* obj) { + auto* cls = se::Class::create("PipelineCapabilities", obj, nullptr, _SE(js_new_cc_render_PipelineCapabilities)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("subpass", _SE(js_cc_render_PipelineCapabilities_subpass_get), _SE(js_cc_render_PipelineCapabilities_subpass_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineCapabilities)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_PipelineCapabilities_proto = cls->getProto(); + __jsb_cc_render_PipelineCapabilities_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderNode_class = nullptr; +se::Object* __jsb_cc_render_RenderNode_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderNode) + +static bool js_delete_cc_render_RenderNode(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderNode) + +static bool js_cc_render_RenderNode_setCustomBehavior(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderNode *arg1 = (cc::render::RenderNode *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setCustomBehavior((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderNode_setCustomBehavior) + +static bool js_cc_render_RenderNode_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderNode *arg1 = (cc::render::RenderNode *) NULL ; + ccstd::string arg2 ; + + arg1 = SE_THIS_OBJECT(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(s); + if (nullptr == arg1) return true; + result = cc_render_RenderNode_name_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_RenderNode_name_get) + +bool js_register_cc_render_RenderNode(se::Object* obj) { + auto* cls = se::Class::create("RenderNode", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_render_RenderNode_name_get), _SE(js_cc_render_RenderNode_name_set)); + + cls->defineFunction("setCustomBehavior", _SE(js_cc_render_RenderNode_setCustomBehavior)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderNode)); + + + cls->install(); + JSBClassType::registerClass(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(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(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(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(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(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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFloat((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setFloat) + +static bool js_cc_render_Setter_setArrayBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + ccstd::string *arg2 = 0 ; + ArrayBuffer *arg3 = (ArrayBuffer *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setArrayBuffer((ccstd::string const &)*arg2,(ArrayBuffer const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setArrayBuffer) + +static bool js_cc_render_Setter_setBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Buffer *arg3 = (gfx::Buffer *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setTexture) + +static bool js_cc_render_Setter_setSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Sampler *arg3 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSampler((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setSampler) + +static bool js_cc_render_Setter_setBuiltinCameraConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinCameraConstants((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinCameraConstants) + +static bool js_cc_render_Setter_setBuiltinDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightConstants((cc::scene::DirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinDirectionalLightConstants) + +static bool js_cc_render_Setter_setBuiltinSphereLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSphereLightConstants((cc::scene::SphereLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSphereLightConstants) + +static bool js_cc_render_Setter_setBuiltinSpotLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightConstants((cc::scene::SpotLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSpotLightConstants) + +static bool js_cc_render_Setter_setBuiltinPointLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinPointLightConstants((cc::scene::PointLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinPointLightConstants) + +static bool js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinRangedDirectionalLightConstants((cc::scene::RangedDirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants) + +static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3,arg4); + + + return true; +} + +static bool js_cc_render_Setter_setBuiltinSpotLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightFrustumConstants((cc::scene::SpotLight const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinSpotLightFrustumConstants) + +static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Setter *arg1 = (cc::render::Setter *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3); + + + return true; +} + +static bool js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants) + +static bool js_delete_cc_render_Setter(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_Setter) + +bool js_register_cc_render_Setter(se::Object* obj) { + auto* cls = se::Class::create("Setter", obj, __jsb_cc_render_RenderNode_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setMat4", _SE(js_cc_render_Setter_setMat4)); + cls->defineFunction("setQuaternion", _SE(js_cc_render_Setter_setQuaternion)); + cls->defineFunction("setColor", _SE(js_cc_render_Setter_setColor)); + cls->defineFunction("setVec4", _SE(js_cc_render_Setter_setVec4)); + cls->defineFunction("setVec2", _SE(js_cc_render_Setter_setVec2)); + cls->defineFunction("setFloat", _SE(js_cc_render_Setter_setFloat)); + cls->defineFunction("setArrayBuffer", _SE(js_cc_render_Setter_setArrayBuffer)); + cls->defineFunction("setBuffer", _SE(js_cc_render_Setter_setBuffer)); + cls->defineFunction("setTexture", _SE(js_cc_render_Setter_setTexture)); + cls->defineFunction("setSampler", _SE(js_cc_render_Setter_setSampler)); + cls->defineFunction("setBuiltinCameraConstants", _SE(js_cc_render_Setter_setBuiltinCameraConstants)); + cls->defineFunction("setBuiltinDirectionalLightConstants", _SE(js_cc_render_Setter_setBuiltinDirectionalLightConstants)); + cls->defineFunction("setBuiltinSphereLightConstants", _SE(js_cc_render_Setter_setBuiltinSphereLightConstants)); + cls->defineFunction("setBuiltinSpotLightConstants", _SE(js_cc_render_Setter_setBuiltinSpotLightConstants)); + cls->defineFunction("setBuiltinPointLightConstants", _SE(js_cc_render_Setter_setBuiltinPointLightConstants)); + cls->defineFunction("setBuiltinRangedDirectionalLightConstants", _SE(js_cc_render_Setter_setBuiltinRangedDirectionalLightConstants)); + cls->defineFunction("setBuiltinSpotLightFrustumConstants", _SE(js_cc_render_Setter_setBuiltinSpotLightFrustumConstants)); + cls->defineFunction("setBuiltinDirectionalLightFrustumConstants", _SE(js_cc_render_Setter_setBuiltinDirectionalLightFrustumConstants)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_Setter)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_Setter_proto = cls->getProto(); + __jsb_cc_render_Setter_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_SceneBuilder_class = nullptr; +se::Object* __jsb_cc_render_SceneBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_SceneBuilder) + +static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ; + IntrusivePtr< cc::scene::Light > arg2 ; + uint32_t arg3 ; + cc::scene::Camera *arg4 = (cc::scene::Camera *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->useLightFrustum(arg2,arg3,(cc::scene::Camera const *)arg4); + + + return true; +} + +static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ; + IntrusivePtr< cc::scene::Light > arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->useLightFrustum(arg2); + + + return true; +} + +static bool js_cc_render_SceneBuilder_useLightFrustum__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::SceneBuilder *arg1 = (cc::render::SceneBuilder *) NULL ; + IntrusivePtr< cc::scene::Light > arg2 ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->useLightFrustum(arg2,arg3); + + + return true; +} + +static bool js_cc_render_SceneBuilder_useLightFrustum(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_SceneBuilder_useLightFrustum__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_SceneBuilder_useLightFrustum) + +static bool js_delete_cc_render_SceneBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_SceneBuilder) + +bool js_register_cc_render_SceneBuilder(se::Object* obj) { + auto* cls = se::Class::create("SceneBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("useLightFrustum", _SE(js_cc_render_SceneBuilder_useLightFrustum)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_SceneBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_SceneBuilder_proto = cls->getProto(); + __jsb_cc_render_SceneBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderQueueBuilder_class = nullptr; +se::Object* __jsb_cc_render_RenderQueueBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderQueueBuilder) + +static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + LightInfo arg3 ; + SceneFlags arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSceneOfCamera(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + SceneFlags arg3 ; + cc::scene::Light *arg4 = (cc::scene::Light *) NULL ; + cc::scene::RenderScene *arg5 = (cc::scene::RenderScene *) NULL ; + cc::render::SceneBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + Material *arg2 = (Material *) NULL ; + uint32_t arg3 ; + SceneFlags arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addFullscreenQuad(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + Material *arg3 = (Material *) NULL ; + uint32_t arg4 ; + SceneFlags arg5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCameraQuad(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + std::vector< cc::scene::Model * > *arg3 = 0 ; + SceneFlags arg4 ; + std::vector< cc::scene::Model * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDraw3D((cc::scene::Camera const *)arg2,(std::vector< cc::scene::Model * > const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addDraw2D(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDraw2D((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addDraw2D) + +static bool js_cc_render_RenderQueueBuilder_addProfiler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addProfiler((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addProfiler) + +static bool js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Color *arg3 = 0 ; + ccstd::string temp2 ; + gfx::Color temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->clearRenderTarget((ccstd::string const &)*arg2,(gfx::Color const &)*arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + gfx::Viewport *arg2 = 0 ; + gfx::Viewport temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setViewport((gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_setViewport) + +static bool js_cc_render_RenderQueueBuilder_addCustomCommand(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + std::string_view arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCustomCommand(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addCustomCommand) + +static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + LightInfo arg3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addSceneOfCamera(arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addSceneOfCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addSceneOfCamera__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addSceneOfCamera) + +static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + SceneFlags arg3 ; + cc::render::SceneBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addScene__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + SceneFlags arg3 ; + cc::scene::Light *arg4 = (cc::scene::Light *) NULL ; + cc::render::SceneBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::render::SceneBuilder *)(arg1)->addScene((cc::scene::Camera const *)arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addScene__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addScene) + +static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + Material *arg2 = (Material *) NULL ; + uint32_t arg3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addFullscreenQuad(arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addFullscreenQuad(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addFullscreenQuad__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addFullscreenQuad) + +static bool js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + Material *arg3 = (Material *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addCameraQuad(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addCameraQuad(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addCameraQuad__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addCameraQuad) + +static bool js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + std::vector< cc::scene::Model * > *arg3 = 0 ; + std::vector< cc::scene::Model * > temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addDraw3D((cc::scene::Camera const *)arg2,(std::vector< cc::scene::Model * > const &)*arg3); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_addDraw3D(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_addDraw3D__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_addDraw3D) + +static bool js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderQueueBuilder *arg1 = (cc::render::RenderQueueBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->clearRenderTarget((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_RenderQueueBuilder_clearRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_RenderQueueBuilder_clearRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderQueueBuilder_clearRenderTarget) + +static bool js_delete_cc_render_RenderQueueBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderQueueBuilder) + +bool js_register_cc_render_RenderQueueBuilder(se::Object* obj) { + auto* cls = se::Class::create("RenderQueueBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addDraw2D", _SE(js_cc_render_RenderQueueBuilder_addDraw2D)); + cls->defineFunction("addProfiler", _SE(js_cc_render_RenderQueueBuilder_addProfiler)); + cls->defineFunction("setViewport", _SE(js_cc_render_RenderQueueBuilder_setViewport)); + cls->defineFunction("addCustomCommand", _SE(js_cc_render_RenderQueueBuilder_addCustomCommand)); + cls->defineFunction("addSceneOfCamera", _SE(js_cc_render_RenderQueueBuilder_addSceneOfCamera)); + cls->defineFunction("addScene", _SE(js_cc_render_RenderQueueBuilder_addScene)); + cls->defineFunction("addFullscreenQuad", _SE(js_cc_render_RenderQueueBuilder_addFullscreenQuad)); + cls->defineFunction("addCameraQuad", _SE(js_cc_render_RenderQueueBuilder_addCameraQuad)); + cls->defineFunction("addDraw3D", _SE(js_cc_render_RenderQueueBuilder_addDraw3D)); + cls->defineFunction("clearRenderTarget", _SE(js_cc_render_RenderQueueBuilder_clearRenderTarget)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderQueueBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_RenderQueueBuilder_proto = cls->getProto(); + __jsb_cc_render_RenderQueueBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_BasicRenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_BasicRenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicRenderPassBuilder) + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + gfx::Color *arg5 = 0 ; + ccstd::string temp2 ; + gfx::Color temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,(gfx::Color const &)*arg5); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + float arg5 ; + uint8_t arg6 ; + gfx::ClearFlagBit arg7 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp3 ; + ccstd::string temp4 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + gfx::Viewport *arg2 = 0 ; + gfx::Viewport temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setViewport((gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_setViewport) + +static bool js_cc_render_BasicRenderPassBuilder_setVersion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + uint64_t arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setVersion((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_setVersion) + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addRenderTarget__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addRenderTarget) + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addDepthStencil((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + float arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::LoadOp arg3 ; + gfx::StoreOp arg4 ; + float arg5 ; + uint8_t arg6 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_BasicRenderPassBuilder_addDepthStencil__SWIG_5(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addDepthStencil) + +static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addTexture) + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + QueueHint arg2 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicRenderPassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicRenderPassBuilder_addQueue__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicRenderPassBuilder_addQueue) + +static bool js_cc_render_BasicRenderPassBuilder_showStatistics_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_render_BasicRenderPassBuilder_showStatistics_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_BasicRenderPassBuilder_showStatistics_set) + +static bool js_cc_render_BasicRenderPassBuilder_showStatistics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicRenderPassBuilder *arg1 = (cc::render::BasicRenderPassBuilder *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_render_BasicRenderPassBuilder_showStatistics_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicRenderPassBuilder_showStatistics_get) + +static bool js_delete_cc_render_BasicRenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_BasicRenderPassBuilder) + +bool js_register_cc_render_BasicRenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("BasicRenderPassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("showStatistics", _SE(js_cc_render_BasicRenderPassBuilder_showStatistics_get), _SE(js_cc_render_BasicRenderPassBuilder_showStatistics_set)); + + cls->defineFunction("setViewport", _SE(js_cc_render_BasicRenderPassBuilder_setViewport)); + cls->defineFunction("setVersion", _SE(js_cc_render_BasicRenderPassBuilder_setVersion)); + cls->defineFunction("addRenderTarget", _SE(js_cc_render_BasicRenderPassBuilder_addRenderTarget)); + cls->defineFunction("addDepthStencil", _SE(js_cc_render_BasicRenderPassBuilder_addDepthStencil)); + cls->defineFunction("addTexture", _SE(js_cc_render_BasicRenderPassBuilder_addTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_BasicRenderPassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicRenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_BasicRenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_BasicRenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_BasicMultisampleRenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicMultisampleRenderPassBuilder) + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget) + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + gfx::ResolveMode arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicMultisampleRenderPassBuilder *arg1 = (cc::render::BasicMultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil) + +static bool js_delete_cc_render_BasicMultisampleRenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_BasicMultisampleRenderPassBuilder) + +bool js_register_cc_render_BasicMultisampleRenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("BasicMultisampleRenderPassBuilder", obj, __jsb_cc_render_BasicRenderPassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("resolveRenderTarget", _SE(js_cc_render_BasicMultisampleRenderPassBuilder_resolveRenderTarget)); + cls->defineFunction("resolveDepthStencil", _SE(js_cc_render_BasicMultisampleRenderPassBuilder_resolveDepthStencil)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicMultisampleRenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_BasicMultisampleRenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_BasicPipeline_class = nullptr; +se::Object* __jsb_cc_render_BasicPipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_BasicPipeline) + +static bool js_cc_render_BasicPipeline_beginSetup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSetup(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_beginSetup) + +static bool js_cc_render_BasicPipeline_endSetup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endSetup(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_endSetup) + +static bool js_cc_render_BasicPipeline_containsResource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)((cc::render::BasicPipeline const *)arg1)->containsResource((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_containsResource) + +static bool js_cc_render_BasicPipeline_addRenderWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *arg7 = 0 ; + ccstd::string temp2 ; + ccstd::string temp7 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + result = (arg1)->addRenderWindow((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,(ccstd::string const &)*arg7); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->updateRenderWindow((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ResourceResidency arg6 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ResourceResidency arg6 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + gfx::Format arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + gfx::Format arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ResourceFlags arg4 ; + ResourceResidency arg5 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addBuffer((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addBuffer) + +static bool js_cc_render_BasicPipeline_updateBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateBuffer((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateBuffer) + +static bool js_cc_render_BasicPipeline_addExternalTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Texture *arg3 = (gfx::Texture *) NULL ; + ResourceFlags arg4 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addExternalTexture((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addExternalTexture) + +static bool js_cc_render_BasicPipeline_updateExternalTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Texture *arg3 = (gfx::Texture *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateExternalTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateExternalTexture) + +static bool js_cc_render_BasicPipeline_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::TextureType arg3 ; + gfx::Format arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + uint32_t arg9 ; + gfx::SampleCount arg10 ; + ResourceFlags arg11 ; + ResourceResidency arg12 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 11) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 11); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[9], &arg11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[10], &arg12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addTexture) + +static bool js_cc_render_BasicPipeline_updateTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + gfx::SampleCount arg9 ; + ccstd::string temp2 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateTexture) + +static bool js_cc_render_BasicPipeline_addResource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ResourceDimension arg3 ; + gfx::Format arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + uint32_t arg9 ; + gfx::SampleCount arg10 ; + ResourceFlags arg11 ; + ResourceResidency arg12 ; + ccstd::string temp2 ; + uint32_t result; + + if(argc != 11) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 11); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[9], &arg11, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[10], &arg12, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addResource((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addResource) + +static bool js_cc_render_BasicPipeline_updateResource(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + uint32_t arg7 ; + uint32_t arg8 ; + gfx::SampleCount arg9 ; + ccstd::string temp2 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateResource((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateResource) + +static bool js_cc_render_BasicPipeline_beginFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginFrame(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_beginFrame) + +static bool js_cc_render_BasicPipeline_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_update) + +static bool js_cc_render_BasicPipeline_endFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endFrame(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_endFrame) + +static bool js_cc_render_BasicPipeline_addRenderPass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp4 ; + cc::render::BasicRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::BasicRenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string *arg6 = 0 ; + ccstd::string temp6 ; + cc::render::BasicMultisampleRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (cc::render::BasicMultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5,(ccstd::string const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addResolvePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::vector< ResolvePair > *arg2 = 0 ; + ccstd::vector< ResolvePair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addResolvePass((ccstd::vector< ResolvePair > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addResolvePass) + +static bool js_cc_render_BasicPipeline_addCopyPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::vector< CopyPair > *arg2 = 0 ; + ccstd::vector< CopyPair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addCopyPass((ccstd::vector< CopyPair > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addCopyPass) + +static bool js_cc_render_BasicPipeline_addBuiltinReflectionProbePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addBuiltinReflectionProbePass((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addBuiltinReflectionProbePass) + +static bool js_cc_render_BasicPipeline_getDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + UpdateFrequency arg3 ; + ccstd::string temp2 ; + gfx::DescriptorSetLayout *result = 0 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout((ccstd::string const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_getDescriptorSetLayout) + +static bool js_cc_render_BasicPipeline_setMat4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setMat4) + +static bool js_cc_render_BasicPipeline_setQuaternion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setQuaternion) + +static bool js_cc_render_BasicPipeline_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::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(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_BasicPipeline_setColor) + +static bool js_cc_render_BasicPipeline_setVec4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setVec4) + +static bool js_cc_render_BasicPipeline_setVec2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setVec2) + +static bool js_cc_render_BasicPipeline_setFloat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + 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(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_BasicPipeline_setFloat) + +static bool js_cc_render_BasicPipeline_setArrayBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ArrayBuffer *arg3 = (ArrayBuffer *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setArrayBuffer((ccstd::string const &)*arg2,(ArrayBuffer const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setArrayBuffer) + +static bool js_cc_render_BasicPipeline_setBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::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(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_BasicPipeline_setBuffer) + +static bool js_cc_render_BasicPipeline_setTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Texture *arg3 = (gfx::Texture *) NULL ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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_BasicPipeline_setTexture) + +static bool js_cc_render_BasicPipeline_setSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::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(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_BasicPipeline_setSampler) + +static bool js_cc_render_BasicPipeline_setBuiltinCameraConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinCameraConstants((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinCameraConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightConstants((cc::scene::DirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinDirectionalLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinSphereLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSphereLightConstants((cc::scene::SphereLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinSphereLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinSpotLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightConstants((cc::scene::SpotLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinSpotLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinPointLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinPointLightConstants((cc::scene::PointLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinPointLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinRangedDirectionalLightConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinRangedDirectionalLightConstants((cc::scene::RangedDirectionalLight const *)arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinRangedDirectionalLightConstants) + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_setBuiltinSpotLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinSpotLightFrustumConstants((cc::scene::SpotLight const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinSpotLightFrustumConstants) + +static bool js_cc_render_BasicPipeline_addRenderWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::scene::RenderWindow *arg6 = (cc::scene::RenderWindow *) NULL ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->addRenderWindow((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_render_BasicPipeline_addRenderWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addRenderWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderWindow) + +static bool js_cc_render_BasicPipeline_updateRenderWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateRenderWindow((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicPipeline_updateRenderWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicPipeline_updateRenderWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateRenderWindow) + +static bool js_cc_render_BasicPipeline_addRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicPipeline_addRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderTarget) + +static bool js_cc_render_BasicPipeline_addDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicPipeline_addDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addDepthStencil) + +static bool js_cc_render_BasicPipeline_updateRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateRenderTarget((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicPipeline_updateRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicPipeline_updateRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateRenderTarget) + +static bool js_cc_render_BasicPipeline_updateDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateDepthStencil((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_BasicPipeline_updateDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_BasicPipeline_updateDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_BasicPipeline_updateDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_updateDepthStencil) + +static bool js_cc_render_BasicPipeline_addRenderPass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + cc::render::BasicRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::BasicRenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicPipeline_addRenderPass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicPipeline_addRenderPass__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addRenderPass) + +static bool js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + cc::render::BasicMultisampleRenderPassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::BasicMultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_BasicPipeline_addMultisampleRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_BasicPipeline_addMultisampleRenderPass__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_addMultisampleRenderPass) + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::DirectionalLight *arg3 = (cc::scene::DirectionalLight *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBuiltinDirectionalLightFrustumConstants((cc::scene::Camera const *)arg2,(cc::scene::DirectionalLight const *)arg3); + + + return true; +} + +static bool js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants) + +static bool js_cc_render_BasicPipeline_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::render::PipelineType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::PipelineType)cc_render_BasicPipeline_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicPipeline_type_get) + +static bool js_cc_render_BasicPipeline_capabilities_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + cc::render::PipelineCapabilities result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_render_BasicPipeline_capabilities_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicPipeline_capabilities_get) + +static bool js_cc_render_BasicPipeline_enableCpuLightCulling_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_render_BasicPipeline_enableCpuLightCulling_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_BasicPipeline_enableCpuLightCulling_set) + +static bool js_cc_render_BasicPipeline_enableCpuLightCulling_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::BasicPipeline *arg1 = (cc::render::BasicPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_render_BasicPipeline_enableCpuLightCulling_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_BasicPipeline_enableCpuLightCulling_get) + +static bool js_delete_cc_render_BasicPipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_BasicPipeline) + +bool js_register_cc_render_BasicPipeline(se::Object* obj) { + auto* cls = se::Class::create("BasicPipeline", obj, __jsb_cc_render_PipelineRuntime_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_render_BasicPipeline_type_get), nullptr); + cls->defineProperty("capabilities", _SE(js_cc_render_BasicPipeline_capabilities_get), nullptr); + cls->defineProperty("enableCpuLightCulling", _SE(js_cc_render_BasicPipeline_enableCpuLightCulling_get), _SE(js_cc_render_BasicPipeline_enableCpuLightCulling_set)); + + cls->defineFunction("beginSetup", _SE(js_cc_render_BasicPipeline_beginSetup)); + cls->defineFunction("endSetup", _SE(js_cc_render_BasicPipeline_endSetup)); + cls->defineFunction("containsResource", _SE(js_cc_render_BasicPipeline_containsResource)); + cls->defineFunction("addBuffer", _SE(js_cc_render_BasicPipeline_addBuffer)); + cls->defineFunction("updateBuffer", _SE(js_cc_render_BasicPipeline_updateBuffer)); + cls->defineFunction("addExternalTexture", _SE(js_cc_render_BasicPipeline_addExternalTexture)); + cls->defineFunction("updateExternalTexture", _SE(js_cc_render_BasicPipeline_updateExternalTexture)); + cls->defineFunction("addTexture", _SE(js_cc_render_BasicPipeline_addTexture)); + cls->defineFunction("updateTexture", _SE(js_cc_render_BasicPipeline_updateTexture)); + cls->defineFunction("addResource", _SE(js_cc_render_BasicPipeline_addResource)); + cls->defineFunction("updateResource", _SE(js_cc_render_BasicPipeline_updateResource)); + cls->defineFunction("beginFrame", _SE(js_cc_render_BasicPipeline_beginFrame)); + cls->defineFunction("update", _SE(js_cc_render_BasicPipeline_update)); + cls->defineFunction("endFrame", _SE(js_cc_render_BasicPipeline_endFrame)); + cls->defineFunction("addResolvePass", _SE(js_cc_render_BasicPipeline_addResolvePass)); + cls->defineFunction("addCopyPass", _SE(js_cc_render_BasicPipeline_addCopyPass)); + cls->defineFunction("addBuiltinReflectionProbePass", _SE(js_cc_render_BasicPipeline_addBuiltinReflectionProbePass)); + cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_render_BasicPipeline_getDescriptorSetLayout)); + cls->defineFunction("setMat4", _SE(js_cc_render_BasicPipeline_setMat4)); + cls->defineFunction("setQuaternion", _SE(js_cc_render_BasicPipeline_setQuaternion)); + cls->defineFunction("setColor", _SE(js_cc_render_BasicPipeline_setColor)); + cls->defineFunction("setVec4", _SE(js_cc_render_BasicPipeline_setVec4)); + cls->defineFunction("setVec2", _SE(js_cc_render_BasicPipeline_setVec2)); + cls->defineFunction("setFloat", _SE(js_cc_render_BasicPipeline_setFloat)); + cls->defineFunction("setArrayBuffer", _SE(js_cc_render_BasicPipeline_setArrayBuffer)); + cls->defineFunction("setBuffer", _SE(js_cc_render_BasicPipeline_setBuffer)); + cls->defineFunction("setTexture", _SE(js_cc_render_BasicPipeline_setTexture)); + cls->defineFunction("setSampler", _SE(js_cc_render_BasicPipeline_setSampler)); + cls->defineFunction("setBuiltinCameraConstants", _SE(js_cc_render_BasicPipeline_setBuiltinCameraConstants)); + cls->defineFunction("setBuiltinDirectionalLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinDirectionalLightConstants)); + cls->defineFunction("setBuiltinSphereLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinSphereLightConstants)); + cls->defineFunction("setBuiltinSpotLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinSpotLightConstants)); + cls->defineFunction("setBuiltinPointLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinPointLightConstants)); + cls->defineFunction("setBuiltinRangedDirectionalLightConstants", _SE(js_cc_render_BasicPipeline_setBuiltinRangedDirectionalLightConstants)); + cls->defineFunction("setBuiltinSpotLightFrustumConstants", _SE(js_cc_render_BasicPipeline_setBuiltinSpotLightFrustumConstants)); + cls->defineFunction("addRenderWindow", _SE(js_cc_render_BasicPipeline_addRenderWindow)); + cls->defineFunction("updateRenderWindow", _SE(js_cc_render_BasicPipeline_updateRenderWindow)); + cls->defineFunction("addRenderTarget", _SE(js_cc_render_BasicPipeline_addRenderTarget)); + cls->defineFunction("addDepthStencil", _SE(js_cc_render_BasicPipeline_addDepthStencil)); + cls->defineFunction("updateRenderTarget", _SE(js_cc_render_BasicPipeline_updateRenderTarget)); + cls->defineFunction("updateDepthStencil", _SE(js_cc_render_BasicPipeline_updateDepthStencil)); + cls->defineFunction("addRenderPass", _SE(js_cc_render_BasicPipeline_addRenderPass)); + cls->defineFunction("addMultisampleRenderPass", _SE(js_cc_render_BasicPipeline_addMultisampleRenderPass)); + cls->defineFunction("setBuiltinDirectionalLightFrustumConstants", _SE(js_cc_render_BasicPipeline_setBuiltinDirectionalLightFrustumConstants)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_BasicPipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_BasicPipeline_proto = cls->getProto(); + __jsb_cc_render_BasicPipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderSubpassBuilder_class = nullptr; +se::Object* __jsb_cc_render_RenderSubpassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderSubpassBuilder) + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + gfx::LoadOp arg5 ; + gfx::StoreOp arg6 ; + gfx::Color *arg7 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + gfx::Color temp7 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &temp7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg7 = &temp7; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5,arg6,(gfx::Color const &)*arg7); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + float arg8 ; + uint8_t arg9 ; + gfx::ClearFlagBit arg10 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addStorageBuffer) + +static bool js_cc_render_RenderSubpassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addStorageImage) + +static bool js_cc_render_RenderSubpassBuilder_setViewport(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + gfx::Viewport *arg2 = 0 ; + gfx::Viewport temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->setViewport((gfx::Viewport const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_setViewport) + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp3 ; + ccstd::string temp4 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_setCustomShaderStages) + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + gfx::LoadOp arg5 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + gfx::LoadOp arg5 ; + gfx::StoreOp arg6 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 6) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_RenderSubpassBuilder_addRenderTarget__SWIG_4(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addRenderTarget) + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_4(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_5(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_6(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + float arg8 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_7(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string *arg5 = 0 ; + gfx::LoadOp arg6 ; + gfx::StoreOp arg7 ; + float arg8 ; + uint8_t arg9 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + ccstd::string temp5 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDepthStencil((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4,(ccstd::string const &)*arg5,arg6,arg7,arg8,arg9); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 9) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_3(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_4(s); + if (ok) { + return true; + } + } + if (argc == 6) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_5(s); + if (ok) { + return true; + } + } + if (argc == 7) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_6(s); + if (ok) { + return true; + } + } + if (argc == 8) { + ok = js_cc_render_RenderSubpassBuilder_addDepthStencil__SWIG_7(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addDepthStencil) + +static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addTexture) + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + QueueHint arg2 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addQueue__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + QueueHint arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + cc::render::RenderQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::RenderQueueBuilder *)(arg1)->addQueue(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderSubpassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_RenderSubpassBuilder_addQueue__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderSubpassBuilder_addQueue) + +static bool js_cc_render_RenderSubpassBuilder_showStatistics_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_render_RenderSubpassBuilder_showStatistics_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_render_RenderSubpassBuilder_showStatistics_set) + +static bool js_cc_render_RenderSubpassBuilder_showStatistics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::render::RenderSubpassBuilder *arg1 = (cc::render::RenderSubpassBuilder *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_render_RenderSubpassBuilder_showStatistics_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_render_RenderSubpassBuilder_showStatistics_get) + +static bool js_delete_cc_render_RenderSubpassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderSubpassBuilder) + +bool js_register_cc_render_RenderSubpassBuilder(se::Object* obj) { + auto* cls = se::Class::create("RenderSubpassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("showStatistics", _SE(js_cc_render_RenderSubpassBuilder_showStatistics_get), _SE(js_cc_render_RenderSubpassBuilder_showStatistics_set)); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_RenderSubpassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_RenderSubpassBuilder_addStorageImage)); + cls->defineFunction("setViewport", _SE(js_cc_render_RenderSubpassBuilder_setViewport)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_RenderSubpassBuilder_setCustomShaderStages)); + cls->defineFunction("addRenderTarget", _SE(js_cc_render_RenderSubpassBuilder_addRenderTarget)); + cls->defineFunction("addDepthStencil", _SE(js_cc_render_RenderSubpassBuilder_addDepthStencil)); + cls->defineFunction("addTexture", _SE(js_cc_render_RenderSubpassBuilder_addTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_RenderSubpassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderSubpassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_RenderSubpassBuilder_proto = cls->getProto(); + __jsb_cc_render_RenderSubpassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_MultisampleRenderSubpassBuilder_class = nullptr; +se::Object* __jsb_cc_render_MultisampleRenderSubpassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderSubpassBuilder) + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget) + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + gfx::ResolveMode arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::MultisampleRenderSubpassBuilder *arg1 = (cc::render::MultisampleRenderSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::ResolveMode arg4 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resolveDepthStencil((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil) + +static bool js_delete_cc_render_MultisampleRenderSubpassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderSubpassBuilder) + +bool js_register_cc_render_MultisampleRenderSubpassBuilder(se::Object* obj) { + auto* cls = se::Class::create("MultisampleRenderSubpassBuilder", obj, __jsb_cc_render_RenderSubpassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("resolveRenderTarget", _SE(js_cc_render_MultisampleRenderSubpassBuilder_resolveRenderTarget)); + cls->defineFunction("resolveDepthStencil", _SE(js_cc_render_MultisampleRenderSubpassBuilder_resolveDepthStencil)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_MultisampleRenderSubpassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_MultisampleRenderSubpassBuilder_proto = cls->getProto(); + __jsb_cc_render_MultisampleRenderSubpassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_ComputeQueueBuilder_class = nullptr; +se::Object* __jsb_cc_render_ComputeQueueBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputeQueueBuilder) + +static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + Material *arg5 = (Material *) NULL ; + uint32_t arg6 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDispatch(arg2,arg3,arg4,arg5,arg6); + + + return true; +} + +static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addDispatch(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeQueueBuilder *arg1 = (cc::render::ComputeQueueBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + Material *arg5 = (Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDispatch(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_ComputeQueueBuilder_addDispatch(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_ComputeQueueBuilder_addDispatch__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputeQueueBuilder_addDispatch) + +static bool js_delete_cc_render_ComputeQueueBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_ComputeQueueBuilder) + +bool js_register_cc_render_ComputeQueueBuilder(se::Object* obj) { + auto* cls = se::Class::create("ComputeQueueBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addDispatch", _SE(js_cc_render_ComputeQueueBuilder_addDispatch)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputeQueueBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_ComputeQueueBuilder_proto = cls->getProto(); + __jsb_cc_render_ComputeQueueBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_ComputeSubpassBuilder_class = nullptr; +se::Object* __jsb_cc_render_ComputeSubpassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputeSubpassBuilder) + +static bool js_cc_render_ComputeSubpassBuilder_addRenderTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addRenderTarget((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addRenderTarget) + +static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addStorageBuffer) + +static bool js_cc_render_ComputeSubpassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addStorageImage) + +static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_setCustomShaderStages) + +static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_ComputeSubpassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addTexture) + +static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputeSubpassBuilder *arg1 = (cc::render::ComputeSubpassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputeSubpassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_ComputeSubpassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputeSubpassBuilder_addQueue) + +static bool js_delete_cc_render_ComputeSubpassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_ComputeSubpassBuilder) + +bool js_register_cc_render_ComputeSubpassBuilder(se::Object* obj) { + auto* cls = se::Class::create("ComputeSubpassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addRenderTarget", _SE(js_cc_render_ComputeSubpassBuilder_addRenderTarget)); + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_ComputeSubpassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_ComputeSubpassBuilder_addStorageImage)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_ComputeSubpassBuilder_setCustomShaderStages)); + cls->defineFunction("addTexture", _SE(js_cc_render_ComputeSubpassBuilder_addTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_ComputeSubpassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputeSubpassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_ComputeSubpassBuilder_proto = cls->getProto(); + __jsb_cc_render_ComputeSubpassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_RenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_RenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_RenderPassBuilder) + +static bool js_cc_render_RenderPassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addStorageBuffer) + +static bool js_cc_render_RenderPassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addStorageImage) + +static bool js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_addRenderSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::RenderSubpassBuilder *result = 0 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::RenderSubpassBuilder *)(arg1)->addRenderSubpass((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addRenderSubpass) + +static bool js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp4 ; + cc::render::MultisampleRenderSubpassBuilder *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::MultisampleRenderSubpassBuilder *)(arg1)->addMultisampleRenderSubpass(arg2,arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass) + +static bool js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputeSubpassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputeSubpassBuilder *)(arg1)->addComputeSubpass((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_setCustomShaderStages) + +static bool js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_addMaterialTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_RenderPassBuilder_addMaterialTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addMaterialTexture) + +static bool js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::RenderPassBuilder *arg1 = (cc::render::RenderPassBuilder *) NULL ; + cc::render::ComputeSubpassBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::ComputeSubpassBuilder *)(arg1)->addComputeSubpass(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_RenderPassBuilder_addComputeSubpass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_RenderPassBuilder_addComputeSubpass__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_RenderPassBuilder_addComputeSubpass) + +static bool js_delete_cc_render_RenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_RenderPassBuilder) + +bool js_register_cc_render_RenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("RenderPassBuilder", obj, __jsb_cc_render_BasicRenderPassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_RenderPassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_RenderPassBuilder_addStorageImage)); + cls->defineFunction("addRenderSubpass", _SE(js_cc_render_RenderPassBuilder_addRenderSubpass)); + cls->defineFunction("addMultisampleRenderSubpass", _SE(js_cc_render_RenderPassBuilder_addMultisampleRenderSubpass)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_RenderPassBuilder_setCustomShaderStages)); + cls->defineFunction("addMaterialTexture", _SE(js_cc_render_RenderPassBuilder_addMaterialTexture)); + cls->defineFunction("addComputeSubpass", _SE(js_cc_render_RenderPassBuilder_addComputeSubpass)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_RenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_RenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_MultisampleRenderPassBuilder_class = nullptr; +se::Object* __jsb_cc_render_MultisampleRenderPassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderPassBuilder) + +static bool js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::MultisampleRenderPassBuilder *arg1 = (cc::render::MultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer) + +static bool js_cc_render_MultisampleRenderPassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::MultisampleRenderPassBuilder *arg1 = (cc::render::MultisampleRenderPassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_MultisampleRenderPassBuilder_addStorageImage) + +static bool js_delete_cc_render_MultisampleRenderPassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_MultisampleRenderPassBuilder) + +bool js_register_cc_render_MultisampleRenderPassBuilder(se::Object* obj) { + auto* cls = se::Class::create("MultisampleRenderPassBuilder", obj, __jsb_cc_render_BasicMultisampleRenderPassBuilder_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_MultisampleRenderPassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_MultisampleRenderPassBuilder_addStorageImage)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_MultisampleRenderPassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_MultisampleRenderPassBuilder_proto = cls->getProto(); + __jsb_cc_render_MultisampleRenderPassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_ComputePassBuilder_class = nullptr; +se::Object* __jsb_cc_render_ComputePassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_ComputePassBuilder) + +static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + uint32_t arg5 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addStorageBuffer) + +static bool js_cc_render_ComputePassBuilder_addStorageImage(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + AccessType arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp2 ; + ccstd::string temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->addStorageImage((ccstd::string const &)*arg2,arg3,(ccstd::string const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addStorageImage) + +static bool js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_setCustomShaderStages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::ShaderStageFlagBit arg3 ; + ccstd::string temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setCustomShaderStages((ccstd::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_setCustomShaderStages) + +static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addTexture__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string *arg3 = 0 ; + gfx::Sampler *arg4 = (gfx::Sampler *) NULL ; + ccstd::string temp2 ; + ccstd::string temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addTexture((ccstd::string const &)*arg2,(ccstd::string const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_ComputePassBuilder_addTexture__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addTexture) + +static bool js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addMaterialTexture((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addMaterialTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_ComputePassBuilder_addMaterialTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addMaterialTexture) + +static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addQueue__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::ComputePassBuilder *arg1 = (cc::render::ComputePassBuilder *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputeQueueBuilder *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputeQueueBuilder *)(arg1)->addQueue((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} + +static bool js_cc_render_ComputePassBuilder_addQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_render_ComputePassBuilder_addQueue__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_render_ComputePassBuilder_addQueue__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_render_ComputePassBuilder_addQueue__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_ComputePassBuilder_addQueue) + +static bool js_delete_cc_render_ComputePassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_ComputePassBuilder) + +bool js_register_cc_render_ComputePassBuilder(se::Object* obj) { + auto* cls = se::Class::create("ComputePassBuilder", obj, __jsb_cc_render_Setter_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_ComputePassBuilder_addStorageBuffer)); + cls->defineFunction("addStorageImage", _SE(js_cc_render_ComputePassBuilder_addStorageImage)); + cls->defineFunction("setCustomShaderStages", _SE(js_cc_render_ComputePassBuilder_setCustomShaderStages)); + cls->defineFunction("addTexture", _SE(js_cc_render_ComputePassBuilder_addTexture)); + cls->defineFunction("addMaterialTexture", _SE(js_cc_render_ComputePassBuilder_addMaterialTexture)); + cls->defineFunction("addQueue", _SE(js_cc_render_ComputePassBuilder_addQueue)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_ComputePassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_ComputePassBuilder_proto = cls->getProto(); + __jsb_cc_render_ComputePassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_Pipeline_class = nullptr; +se::Object* __jsb_cc_render_Pipeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_Pipeline) + +static bool js_cc_render_Pipeline_addStorageBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + ResourceResidency arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addStorageTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ResourceResidency arg6 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addShadingRateTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ResourceResidency arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + gfx::Format arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageBuffer((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + gfx::Format arg5 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_render_Pipeline_updateShadingRateTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_updateShadingRateTexture) + +static bool js_cc_render_Pipeline_addRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + ccstd::string *arg4 = 0 ; + ccstd::string temp4 ; + cc::render::RenderPassBuilder *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (cc::render::RenderPassBuilder *)(arg1)->addRenderPass(arg2,arg3,(ccstd::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addRenderPass) + +static bool js_cc_render_Pipeline_addMultisampleRenderPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string *arg6 = 0 ; + ccstd::string temp6 ; + cc::render::MultisampleRenderPassBuilder *result = 0 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + result = (cc::render::MultisampleRenderPassBuilder *)(arg1)->addMultisampleRenderPass(arg2,arg3,arg4,arg5,(ccstd::string const &)*arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addMultisampleRenderPass) + +static bool js_cc_render_Pipeline_addComputePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::render::ComputePassBuilder *result = 0 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::render::ComputePassBuilder *)(arg1)->addComputePass((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addComputePass) + +static bool js_cc_render_Pipeline_addUploadPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::vector< UploadPair > *arg2 = 0 ; + ccstd::vector< UploadPair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addUploadPass(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addUploadPass) + +static bool js_cc_render_Pipeline_addMovePass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::vector< MovePair > *arg2 = 0 ; + ccstd::vector< MovePair > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + (arg1)->addMovePass((ccstd::vector< MovePair > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addMovePass) + +static bool js_cc_render_Pipeline_addCustomBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::BufferInfo *arg3 = 0 ; + std::string *arg4 = 0 ; + ccstd::string temp2 ; + gfx::BufferInfo temp3 ; + std::string temp4 ; + uint32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (arg1)->addCustomBuffer((ccstd::string const &)*arg2,(gfx::BufferInfo const &)*arg3,(std::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addCustomBuffer) + +static bool js_cc_render_Pipeline_addCustomTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::TextureInfo *arg3 = 0 ; + std::string *arg4 = 0 ; + ccstd::string temp2 ; + gfx::TextureInfo temp3 ; + std::string temp4 ; + uint32_t result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (arg1)->addCustomTexture((ccstd::string const &)*arg2,(gfx::TextureInfo const &)*arg3,(std::string const &)*arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addCustomTexture) + +static bool js_cc_render_Pipeline_addStorageBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageBuffer((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_Pipeline_addStorageBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_Pipeline_addStorageBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addStorageBuffer) + +static bool js_cc_render_Pipeline_addStorageTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + gfx::Format arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addStorageTexture((ccstd::string const &)*arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addStorageTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_render_Pipeline_addStorageTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_render_Pipeline_addStorageTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addStorageTexture) + +static bool js_cc_render_Pipeline_addShadingRateTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (arg1)->addShadingRateTexture((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_render_Pipeline_addShadingRateTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_Pipeline_addShadingRateTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_Pipeline_addShadingRateTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_addShadingRateTexture) + +static bool js_cc_render_Pipeline_updateStorageBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageBuffer((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_render_Pipeline_updateStorageBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_render_Pipeline_updateStorageBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_updateStorageBuffer) + +static bool js_cc_render_Pipeline_updateStorageTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::render::Pipeline *arg1 = (cc::render::Pipeline *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateStorageTexture((ccstd::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_render_Pipeline_updateStorageTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_render_Pipeline_updateStorageTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_render_Pipeline_updateStorageTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_render_Pipeline_updateStorageTexture) + +static bool js_delete_cc_render_Pipeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_Pipeline) + +bool js_register_cc_render_Pipeline(se::Object* obj) { + auto* cls = se::Class::create("Pipeline", obj, __jsb_cc_render_BasicPipeline_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateShadingRateTexture", _SE(js_cc_render_Pipeline_updateShadingRateTexture)); + cls->defineFunction("addRenderPass", _SE(js_cc_render_Pipeline_addRenderPass)); + cls->defineFunction("addMultisampleRenderPass", _SE(js_cc_render_Pipeline_addMultisampleRenderPass)); + cls->defineFunction("addComputePass", _SE(js_cc_render_Pipeline_addComputePass)); + cls->defineFunction("addUploadPass", _SE(js_cc_render_Pipeline_addUploadPass)); + cls->defineFunction("addMovePass", _SE(js_cc_render_Pipeline_addMovePass)); + cls->defineFunction("addCustomBuffer", _SE(js_cc_render_Pipeline_addCustomBuffer)); + cls->defineFunction("addCustomTexture", _SE(js_cc_render_Pipeline_addCustomTexture)); + cls->defineFunction("addStorageBuffer", _SE(js_cc_render_Pipeline_addStorageBuffer)); + cls->defineFunction("addStorageTexture", _SE(js_cc_render_Pipeline_addStorageTexture)); + cls->defineFunction("addShadingRateTexture", _SE(js_cc_render_Pipeline_addShadingRateTexture)); + cls->defineFunction("updateStorageBuffer", _SE(js_cc_render_Pipeline_updateStorageBuffer)); + cls->defineFunction("updateStorageTexture", _SE(js_cc_render_Pipeline_updateStorageTexture)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_Pipeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_Pipeline_proto = cls->getProto(); + __jsb_cc_render_Pipeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_PipelinePassBuilder_class = nullptr; +se::Object* __jsb_cc_render_PipelinePassBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelinePassBuilder) + +static bool js_delete_cc_render_PipelinePassBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelinePassBuilder) + +static bool js_cc_render_PipelinePassBuilder_getConfigOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelinePassBuilder *arg1 = (cc::render::PipelinePassBuilder *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::render::PipelinePassBuilder const *)arg1)->getConfigOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelinePassBuilder_getConfigOrder) + +static bool js_cc_render_PipelinePassBuilder_getRenderOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelinePassBuilder *arg1 = (cc::render::PipelinePassBuilder *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::render::PipelinePassBuilder const *)arg1)->getRenderOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelinePassBuilder_getRenderOrder) + +bool js_register_cc_render_PipelinePassBuilder(se::Object* obj) { + auto* cls = se::Class::create("PipelinePassBuilder", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getConfigOrder", _SE(js_cc_render_PipelinePassBuilder_getConfigOrder)); + cls->defineFunction("getRenderOrder", _SE(js_cc_render_PipelinePassBuilder_getRenderOrder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelinePassBuilder)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_render_PipelinePassBuilder_proto = cls->getProto(); + __jsb_cc_render_PipelinePassBuilder_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_render_PipelineBuilder_class = nullptr; +se::Object* __jsb_cc_render_PipelineBuilder_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_render_PipelineBuilder) + +static bool js_delete_cc_render_PipelineBuilder(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_render_PipelineBuilder) + +static bool js_cc_render_PipelineBuilder_windowResize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ; + cc::render::BasicPipeline *arg2 = (cc::render::BasicPipeline *) NULL ; + cc::scene::RenderWindow *arg3 = (cc::scene::RenderWindow *) NULL ; + cc::scene::Camera *arg4 = (cc::scene::Camera *) NULL ; + uint32_t arg5 ; + uint32_t arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->windowResize(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelineBuilder_windowResize) + +static bool js_cc_render_PipelineBuilder_setup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ; + ccstd::vector< cc::scene::Camera * > *arg2 = 0 ; + cc::render::BasicPipeline *arg3 = (cc::render::BasicPipeline *) NULL ; + ccstd::vector< cc::scene::Camera * > temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setup((ccstd::vector< cc::scene::Camera * > const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelineBuilder_setup) + +static bool js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::PipelineBuilder *arg1 = (cc::render::PipelineBuilder *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged) + +bool js_register_cc_render_PipelineBuilder(se::Object* obj) { + auto* cls = se::Class::create("PipelineBuilder", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("windowResize", _SE(js_cc_render_PipelineBuilder_windowResize)); + cls->defineFunction("setup", _SE(js_cc_render_PipelineBuilder_setup)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_render_PipelineBuilder_onGlobalPipelineStateChanged)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_PipelineBuilder)); + + + cls->install(); + JSBClassType::registerClass(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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = ((cc::render::RenderingModule const *)arg1)->getPassID((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderingModule_getPassID) + +static bool js_cc_render_RenderingModule_getSubpassID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ; + uint32_t arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + uint32_t result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = ((cc::render::RenderingModule const *)arg1)->getSubpassID(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderingModule_getSubpassID) + +static bool js_cc_render_RenderingModule_getPhaseID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::render::RenderingModule *arg1 = (cc::render::RenderingModule *) NULL ; + uint32_t arg2 ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + uint32_t result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = ((cc::render::RenderingModule const *)arg1)->getPhaseID(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_render_RenderingModule_getPhaseID) + +bool js_register_cc_render_RenderingModule(se::Object* obj) { + auto* cls = se::Class::create("RenderingModule", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getPassID", _SE(js_cc_render_RenderingModule_getPassID)); + cls->defineFunction("getSubpassID", _SE(js_cc_render_RenderingModule_getSubpassID)); + cls->defineFunction("getPhaseID", _SE(js_cc_render_RenderingModule_getPhaseID)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_render_RenderingModule)); + + + cls->install(); + JSBClassType::registerClass(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(cls); + + __jsb_cc_render_Factory_proto = cls->getProto(); + __jsb_cc_render_Factory_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_render(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("render", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("render", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_render_PipelineRuntime(ns); + js_register_cc_render_PipelineCapabilities(ns); + js_register_cc_render_RenderNode(ns); + js_register_cc_render_Setter(ns); + js_register_cc_render_SceneBuilder(ns); + js_register_cc_render_RenderQueueBuilder(ns); + js_register_cc_render_BasicRenderPassBuilder(ns); + js_register_cc_render_BasicMultisampleRenderPassBuilder(ns); + js_register_cc_render_BasicPipeline(ns); + js_register_cc_render_RenderSubpassBuilder(ns); + js_register_cc_render_MultisampleRenderSubpassBuilder(ns); + js_register_cc_render_ComputeQueueBuilder(ns); + js_register_cc_render_ComputeSubpassBuilder(ns); + js_register_cc_render_RenderPassBuilder(ns); + js_register_cc_render_MultisampleRenderPassBuilder(ns); + js_register_cc_render_ComputePassBuilder(ns); + js_register_cc_render_Pipeline(ns); + js_register_cc_render_PipelinePassBuilder(ns); + js_register_cc_render_PipelineBuilder(ns); + js_register_cc_render_RenderingModule(ns); + js_register_cc_render_Factory(ns); + + /* Register global variables & global functions */ + + + + return true; +} + + +#if defined(__clang__) +#pragma clang diagnostic pop +#elif defined(__GNUC__) || defined(__GNUG__) +#pragma GCC diagnostic pop +#elif defined(_MSC_VER) +#pragma warning(pop) +#endif +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_render_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_render_auto.h new file mode 100644 index 0000000000..e73de7689a --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_render_auto.h @@ -0,0 +1,154 @@ +// 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. +****************************************************************************/ + +#pragma once +#include +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "renderer/pipeline/custom/RenderInterfaceTypes.h" + + + +bool register_all_render(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelineRuntime); +extern se::Object *__jsb_cc_render_PipelineRuntime_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelineRuntime_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelineCapabilities); +extern se::Object *__jsb_cc_render_PipelineCapabilities_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelineCapabilities_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::render::PipelineCapabilities * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderNode); +extern se::Object *__jsb_cc_render_RenderNode_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderNode_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::Setter); +extern se::Object *__jsb_cc_render_Setter_proto; // NOLINT +extern se::Class * __jsb_cc_render_Setter_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::SceneBuilder); +extern se::Object *__jsb_cc_render_SceneBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_SceneBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderQueueBuilder); +extern se::Object *__jsb_cc_render_RenderQueueBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderQueueBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::BasicRenderPassBuilder); +extern se::Object *__jsb_cc_render_BasicRenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_BasicRenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::BasicMultisampleRenderPassBuilder); +extern se::Object *__jsb_cc_render_BasicMultisampleRenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_BasicMultisampleRenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::BasicPipeline); +extern se::Object *__jsb_cc_render_BasicPipeline_proto; // NOLINT +extern se::Class * __jsb_cc_render_BasicPipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderSubpassBuilder); +extern se::Object *__jsb_cc_render_RenderSubpassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderSubpassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::MultisampleRenderSubpassBuilder); +extern se::Object *__jsb_cc_render_MultisampleRenderSubpassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_MultisampleRenderSubpassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::ComputeQueueBuilder); +extern se::Object *__jsb_cc_render_ComputeQueueBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_ComputeQueueBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::ComputeSubpassBuilder); +extern se::Object *__jsb_cc_render_ComputeSubpassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_ComputeSubpassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderPassBuilder); +extern se::Object *__jsb_cc_render_RenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::MultisampleRenderPassBuilder); +extern se::Object *__jsb_cc_render_MultisampleRenderPassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_MultisampleRenderPassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::ComputePassBuilder); +extern se::Object *__jsb_cc_render_ComputePassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_ComputePassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::Pipeline); +extern se::Object *__jsb_cc_render_Pipeline_proto; // NOLINT +extern se::Class * __jsb_cc_render_Pipeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelinePassBuilder); +extern se::Object *__jsb_cc_render_PipelinePassBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelinePassBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::PipelineBuilder); +extern se::Object *__jsb_cc_render_PipelineBuilder_proto; // NOLINT +extern se::Class * __jsb_cc_render_PipelineBuilder_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::RenderingModule); +extern se::Object *__jsb_cc_render_RenderingModule_proto; // NOLINT +extern se::Class * __jsb_cc_render_RenderingModule_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::render::Factory); +extern se::Object *__jsb_cc_render_Factory_proto; // NOLINT +extern se::Class * __jsb_cc_render_Factory_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_scene_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_scene_auto.cpp new file mode 100644 index 0000000000..71b057048b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_scene_auto.cpp @@ -0,0 +1,30785 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_scene_auto.h" +#include "bindings/auto/jsb_gfx_auto.h" +#include "bindings/auto/jsb_pipeline_auto.h" +#include "bindings/auto/jsb_geometry_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_render_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_2d_auto.h" + +using namespace cc; + + +#define cc_Root_device_get(self_) self_->getDevice() +#define cc_Root_device_set(self_, val_) self_->setDevice(val_) + + +#define cc_Root__device_get(self_) self_->getDevice() +#define cc_Root__device_set(self_, val_) self_->setDevice(val_) + + +#define cc_Root_mainWindow_get(self_) self_->getMainWindow() + + +#define cc_Root_curWindow_get(self_) self_->getCurWindow() +#define cc_Root_curWindow_set(self_, val_) self_->setCurWindow(val_) + + +#define cc_Root_tempWindow_get(self_) self_->getTempWindow() +#define cc_Root_tempWindow_set(self_, val_) self_->setTempWindow(val_) + + +#define cc_Root_windows_get(self_) self_->getWindows() + + +#define cc_Root_scenes_get(self_) self_->getScenes() + + +#define cc_Root_cumulativeTime_get(self_) self_->getCumulativeTime() + + +#define cc_Root_frameTime_get(self_) self_->getFrameTime() + + +#define cc_Root_frameCount_get(self_) self_->getFrameCount() + + +#define cc_Root_fps_get(self_) self_->getFps() + + +#define cc_Root_fixedFPS_get(self_) self_->getFixedFPS() +#define cc_Root_fixedFPS_set(self_, val_) self_->setFixedFPS(val_) + + +#define cc_Root_useDeferredPipeline_get(self_) self_->isUsingDeferredPipeline() + + +#define cc_Root_usesCustomPipeline_get(self_) self_->usesCustomPipeline() + + +#define cc_Root_pipeline_get(self_) self_->getPipeline() + + +#define cc_Root_customPipeline_get(self_) self_->getCustomPipeline() + + +#define cc_Root_cameraList_get(self_) self_->getCameraList() + + +#define cc_Root_debugView_get(self_) self_->getDebugView() + + +#define cc_scene_RenderWindow_width_get(self_) self_->getWidth() + + +#define cc_scene_RenderWindow_height_get(self_) self_->getHeight() + + +#define cc_scene_RenderWindow_framebuffer_get(self_) self_->getFramebuffer() + + +#define cc_scene_RenderWindow_cameras_get(self_) self_->getCameras() + + +#define cc_scene_RenderWindow_swapchain_get(self_) self_->getSwapchain() + + +#define cc_scene_RenderWindow_renderWindowId_get(self_) self_->getRenderWindowId() + + +#define cc_scene_RenderWindow_colorName_get(self_) self_->getColorName() + + +#define cc_scene_RenderWindow_depthStencilName_get(self_) self_->getDepthStencilName() + + +#define cc_scene_Pass_root_get(self_) self_->getRoot() + + +#define cc_scene_Pass_device_get(self_) self_->getDevice() + + +#define cc_scene_Pass_shaderInfo_get(self_) self_->getShaderInfo() + + +#define cc_scene_Pass_localSetLayout_get(self_) self_->getLocalSetLayout() + + +#define cc_scene_Pass_program_get(self_) self_->getProgram() + + +#define cc_scene_Pass_properties_get(self_) self_->getProperties() + + +#define cc_scene_Pass_defines_get(self_) self_->getDefines() + + +#define cc_scene_Pass_passIndex_get(self_) self_->getPassIndex() + + +#define cc_scene_Pass_propertyIndex_get(self_) self_->getPropertyIndex() + + +#define cc_scene_Pass_dynamics_get(self_) self_->getDynamics() + + +#define cc_scene_Pass_rootBufferDirty_get(self_) self_->isRootBufferDirty() + + +#define cc_scene_Pass_priority_get(self_) self_->getPriority() + + +#define cc_scene_Pass_primitive_get(self_) self_->getPrimitive() + + +#define cc_scene_Pass_stage_get(self_) self_->getStage() + + +#define cc_scene_Pass_phase_get(self_) self_->getPhase() + + +#define cc_scene_Pass_phaseID_get(self_) self_->getPhaseID() + + +#define cc_scene_Pass_rasterizerState_get(self_) self_->getRasterizerState() + + +#define cc_scene_Pass_depthStencilState_get(self_) self_->getDepthStencilState() + + +#define cc_scene_Pass_blendState_get(self_) self_->getBlendState() + + +#define cc_scene_Pass_dynamicStates_get(self_) self_->getDynamicStates() + + +#define cc_scene_Pass_batchingScheme_get(self_) self_->getBatchingScheme() + + +#define cc_scene_Pass_descriptorSet_get(self_) self_->getDescriptorSet() + + +#define cc_scene_Pass_hash_get(self_) self_->getHash() + + +#define cc_scene_Pass_pipelineLayout_get(self_) self_->getPipelineLayout() + + +#define cc_PassInstance_parent_get(self_) self_->getParent() + + +#define cc_Node_uuid_get(self_) self_->getUuid() + + +#define cc_Node_angle_get(self_) self_->getAngle() +#define cc_Node_angle_set(self_, val_) self_->setAngle(val_) + + +#define cc_Node_matrix_set(self_, val_) self_->setMatrix(val_) + + +#define cc_Node_hasChangedFlags_get(self_) self_->getChangedFlags() +#define cc_Node_hasChangedFlags_set(self_, val_) self_->setChangedFlags(val_) + + +#define cc_Node_flagChangedVersion_get(self_) self_->getFlagChangedVersion() + + +#define cc_Node__persistNode_get(self_) self_->isPersistNode() +#define cc_Node__persistNode_set(self_, val_) self_->setPersistNode(val_) + + +#define cc_Node_mobility_get(self_) self_->getMobility() +#define cc_Node_mobility_set(self_, val_) self_->setMobility(val_) + + +#define cc_Node_isSkipTransformUpdate_get(self_) self_->getIsSkipTransformUpdate() +#define cc_Node_isSkipTransformUpdate_set(self_, val_) self_->setIsSkipTransformUpdate(val_) + + +#define cc_scene_Ambient_skyColor_get(self_) self_->getSkyColor() +#define cc_scene_Ambient_skyColor_set(self_, val_) self_->setSkyColor(val_) + + +#define cc_scene_Ambient_skyIllum_get(self_) self_->getSkyIllum() +#define cc_scene_Ambient_skyIllum_set(self_, val_) self_->setSkyIllum(val_) + + +#define cc_scene_Ambient_groundAlbedo_get(self_) self_->getGroundAlbedo() +#define cc_scene_Ambient_groundAlbedo_set(self_, val_) self_->setGroundAlbedo(val_) + + +#define cc_scene_Ambient_enabled_get(self_) self_->isEnabled() +#define cc_scene_Ambient_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Ambient_mipmapCount_get(self_) self_->getMipmapCount() +#define cc_scene_Ambient_mipmapCount_set(self_, val_) self_->setMipmapCount(val_) + + +#define cc_scene_Light_baked_get(self_) self_->isBaked() +#define cc_scene_Light_baked_set(self_, val_) self_->setBaked(val_) + + +#define cc_scene_Light_color_get(self_) self_->getColor() +#define cc_scene_Light_color_set(self_, val_) self_->setColor(val_) + + +#define cc_scene_Light_useColorTemperature_get(self_) self_->isUseColorTemperature() +#define cc_scene_Light_useColorTemperature_set(self_, val_) self_->setUseColorTemperature(val_) + + +#define cc_scene_Light_colorTemperature_get(self_) self_->getColorTemperature() +#define cc_scene_Light_colorTemperature_set(self_, val_) self_->setColorTemperature(val_) + + +#define cc_scene_Light_node_get(self_) self_->getNode() +#define cc_scene_Light_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_Light_type_get(self_) self_->getType() +#define cc_scene_Light_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Light_name_get(self_) self_->getName() +#define cc_scene_Light_name_set(self_, val_) self_->setName(val_) + + +#define cc_scene_Light_scene_get(self_) self_->getScene() + + +#define cc_scene_Light_visibility_get(self_) self_->getVisibility() +#define cc_scene_Light_visibility_set(self_, val_) self_->setVisibility(val_) + + +#define cc_scene_Light_colorTemperatureRGB_get(self_) self_->getColorTemperatureRGB() +#define cc_scene_Light_colorTemperatureRGB_set(self_, val_) self_->setColorTemperatureRGB(val_) + + +#define cc_scene_LODData_screenUsagePercentage_get(self_) self_->getScreenUsagePercentage() +#define cc_scene_LODData_screenUsagePercentage_set(self_, val_) self_->setScreenUsagePercentage(val_) + + +#define cc_scene_LODData_models_get(self_) self_->getModels() + + +#define cc_scene_LODGroup_lodCount_get(self_) self_->getLodCount() + + +#define cc_scene_LODGroup_enabled_get(self_) self_->isEnabled() +#define cc_scene_LODGroup_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_LODGroup_localBoundaryCenter_get(self_) self_->getLocalBoundaryCenter() +#define cc_scene_LODGroup_localBoundaryCenter_set(self_, val_) self_->setLocalBoundaryCenter(val_) + + +#define cc_scene_LODGroup_objectSize_get(self_) self_->getObjectSize() +#define cc_scene_LODGroup_objectSize_set(self_, val_) self_->setObjectSize(val_) + + +#define cc_scene_LODGroup_node_get(self_) self_->getNode() +#define cc_scene_LODGroup_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_LODGroup_lodDataArray_get(self_) self_->getLodDataArray() + + +#define cc_scene_LODGroup_scene_get(self_) self_->getScene() + + +#define cc_scene_DirectionalLight_direction_get(self_) self_->getDirection() +#define cc_scene_DirectionalLight_direction_set(self_, val_) self_->setDirection(val_) + + +#define cc_scene_DirectionalLight_illuminance_get(self_) self_->getIlluminance() +#define cc_scene_DirectionalLight_illuminance_set(self_, val_) self_->setIlluminance(val_) + + +#define cc_scene_DirectionalLight_illuminanceHDR_get(self_) self_->getIlluminanceHDR() +#define cc_scene_DirectionalLight_illuminanceHDR_set(self_, val_) self_->setIlluminanceHDR(val_) + + +#define cc_scene_DirectionalLight_illuminanceLDR_get(self_) self_->getIlluminanceLDR() +#define cc_scene_DirectionalLight_illuminanceLDR_set(self_, val_) self_->setIlluminanceLDR(val_) + + +#define cc_scene_DirectionalLight_shadowEnabled_get(self_) self_->isShadowEnabled() +#define cc_scene_DirectionalLight_shadowEnabled_set(self_, val_) self_->setShadowEnabled(val_) + + +#define cc_scene_DirectionalLight_shadowPcf_get(self_) self_->getShadowPcf() +#define cc_scene_DirectionalLight_shadowPcf_set(self_, val_) self_->setShadowPcf(val_) + + +#define cc_scene_DirectionalLight_shadowBias_get(self_) self_->getShadowBias() +#define cc_scene_DirectionalLight_shadowBias_set(self_, val_) self_->setShadowBias(val_) + + +#define cc_scene_DirectionalLight_shadowNormalBias_get(self_) self_->getShadowNormalBias() +#define cc_scene_DirectionalLight_shadowNormalBias_set(self_, val_) self_->setShadowNormalBias(val_) + + +#define cc_scene_DirectionalLight_shadowSaturation_get(self_) self_->getShadowSaturation() +#define cc_scene_DirectionalLight_shadowSaturation_set(self_, val_) self_->setShadowSaturation(val_) + + +#define cc_scene_DirectionalLight_shadowDistance_get(self_) self_->getShadowDistance() +#define cc_scene_DirectionalLight_shadowDistance_set(self_, val_) self_->setShadowDistance(val_) + + +#define cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get(self_) self_->getShadowInvisibleOcclusionRange() +#define cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set(self_, val_) self_->setShadowInvisibleOcclusionRange(val_) + + +#define cc_scene_DirectionalLight_shadowFixedArea_get(self_) self_->isShadowFixedArea() +#define cc_scene_DirectionalLight_shadowFixedArea_set(self_, val_) self_->setShadowFixedArea(val_) + + +#define cc_scene_DirectionalLight_shadowNear_get(self_) self_->getShadowNear() +#define cc_scene_DirectionalLight_shadowNear_set(self_, val_) self_->setShadowNear(val_) + + +#define cc_scene_DirectionalLight_shadowFar_get(self_) self_->getShadowFar() +#define cc_scene_DirectionalLight_shadowFar_set(self_, val_) self_->setShadowFar(val_) + + +#define cc_scene_DirectionalLight_shadowOrthoSize_get(self_) self_->getShadowOrthoSize() +#define cc_scene_DirectionalLight_shadowOrthoSize_set(self_, val_) self_->setShadowOrthoSize(val_) + + +#define cc_scene_DirectionalLight_csmLevel_get(self_) self_->getCSMLevel() +#define cc_scene_DirectionalLight_csmLevel_set(self_, val_) self_->setCSMLevel(val_) + + +#define cc_scene_DirectionalLight_csmNeedUpdate_get(self_) self_->isCSMNeedUpdate() +#define cc_scene_DirectionalLight_csmNeedUpdate_set(self_, val_) self_->setCSMNeedUpdate(val_) + + +#define cc_scene_DirectionalLight_csmLayerLambda_get(self_) self_->getCSMLayerLambda() +#define cc_scene_DirectionalLight_csmLayerLambda_set(self_, val_) self_->setCSMLayerLambda(val_) + + +#define cc_scene_DirectionalLight_csmOptimizationMode_get(self_) self_->getCSMOptimizationMode() +#define cc_scene_DirectionalLight_csmOptimizationMode_set(self_, val_) self_->setCSMOptimizationMode(val_) + + +#define cc_scene_DirectionalLight_csmLayersTransition_get(self_) self_->getCSMLayersTransition() +#define cc_scene_DirectionalLight_csmLayersTransition_set(self_, val_) self_->setCSMLayersTransition(val_) + + +#define cc_scene_DirectionalLight_csmTransitionRange_get(self_) self_->getCSMTransitionRange() +#define cc_scene_DirectionalLight_csmTransitionRange_set(self_, val_) self_->setCSMTransitionRange(val_) + + +#define cc_scene_SpotLight_position_get(self_) self_->getPosition() + + +#define cc_scene_SpotLight_range_get(self_) self_->getRange() +#define cc_scene_SpotLight_range_set(self_, val_) self_->setRange(val_) + + +#define cc_scene_SpotLight_luminance_get(self_) self_->getLuminance() +#define cc_scene_SpotLight_luminance_set(self_, val_) self_->setLuminance(val_) + + +#define cc_scene_SpotLight_luminanceHDR_get(self_) self_->getLuminanceHDR() +#define cc_scene_SpotLight_luminanceHDR_set(self_, val_) self_->setLuminanceHDR(val_) + + +#define cc_scene_SpotLight_luminanceLDR_get(self_) self_->getLuminanceLDR() +#define cc_scene_SpotLight_luminanceLDR_set(self_, val_) self_->setLuminanceLDR(val_) + + +#define cc_scene_SpotLight_direction_get(self_) self_->getDirection() + + +#define cc_scene_SpotLight_spotAngle_get(self_) self_->getSpotAngle() +#define cc_scene_SpotLight_spotAngle_set(self_, val_) self_->setSpotAngle(val_) + + +#define cc_scene_SpotLight_angle_get(self_) self_->getAngle() + + +#define cc_scene_SpotLight_aabb_get(self_) self_->getAABB() + + +#define cc_scene_SpotLight_frustum_get(self_) self_->getFrustum() +#define cc_scene_SpotLight_frustum_set(self_, val_) self_->setFrustum(val_) + + +#define cc_scene_SpotLight_shadowEnabled_get(self_) self_->isShadowEnabled() +#define cc_scene_SpotLight_shadowEnabled_set(self_, val_) self_->setShadowEnabled(val_) + + +#define cc_scene_SpotLight_shadowPcf_get(self_) self_->getShadowPcf() +#define cc_scene_SpotLight_shadowPcf_set(self_, val_) self_->setShadowPcf(val_) + + +#define cc_scene_SpotLight_shadowBias_get(self_) self_->getShadowBias() +#define cc_scene_SpotLight_shadowBias_set(self_, val_) self_->setShadowBias(val_) + + +#define cc_scene_SpotLight_shadowNormalBias_get(self_) self_->getShadowNormalBias() +#define cc_scene_SpotLight_shadowNormalBias_set(self_, val_) self_->setShadowNormalBias(val_) + + +#define cc_scene_SpotLight_size_get(self_) self_->getSize() +#define cc_scene_SpotLight_size_set(self_, val_) self_->setSize(val_) + + +#define cc_scene_SpotLight_angleAttenuationStrength_get(self_) self_->getAngleAttenuationStrength() +#define cc_scene_SpotLight_angleAttenuationStrength_set(self_, val_) self_->setAngleAttenuationStrength(val_) + + +#define cc_scene_SphereLight_position_get(self_) self_->getPosition() +#define cc_scene_SphereLight_position_set(self_, val_) self_->setPosition(val_) + + +#define cc_scene_SphereLight_size_get(self_) self_->getSize() +#define cc_scene_SphereLight_size_set(self_, val_) self_->setSize(val_) + + +#define cc_scene_SphereLight_range_get(self_) self_->getRange() +#define cc_scene_SphereLight_range_set(self_, val_) self_->setRange(val_) + + +#define cc_scene_SphereLight_luminance_get(self_) self_->getLuminance() +#define cc_scene_SphereLight_luminance_set(self_, val_) self_->setLuminance(val_) + + +#define cc_scene_SphereLight_luminanceHDR_get(self_) self_->getLuminanceHDR() +#define cc_scene_SphereLight_luminanceHDR_set(self_, val_) self_->setLuminanceHDR(val_) + + +#define cc_scene_SphereLight_luminanceLDR_get(self_) self_->getLuminanceLDR() +#define cc_scene_SphereLight_luminanceLDR_set(self_, val_) self_->setLuminanceLDR(val_) + + +#define cc_scene_SphereLight_aabb_get(self_) self_->getAABB() + + +#define cc_scene_PointLight_position_get(self_) self_->getPosition() +#define cc_scene_PointLight_position_set(self_, val_) self_->setPosition(val_) + + +#define cc_scene_PointLight_range_get(self_) self_->getRange() +#define cc_scene_PointLight_range_set(self_, val_) self_->setRange(val_) + + +#define cc_scene_PointLight_luminance_get(self_) self_->getLuminance() +#define cc_scene_PointLight_luminance_set(self_, val_) self_->setLuminance(val_) + + +#define cc_scene_PointLight_luminanceHDR_get(self_) self_->getLuminanceHDR() +#define cc_scene_PointLight_luminanceHDR_set(self_, val_) self_->setLuminanceHDR(val_) + + +#define cc_scene_PointLight_luminanceLDR_get(self_) self_->getLuminanceLDR() +#define cc_scene_PointLight_luminanceLDR_set(self_, val_) self_->setLuminanceLDR(val_) + + +#define cc_scene_PointLight_aabb_get(self_) self_->getAABB() + + +#define cc_scene_RangedDirectionalLight_illuminance_get(self_) self_->getIlluminance() +#define cc_scene_RangedDirectionalLight_illuminance_set(self_, val_) self_->setIlluminance(val_) + + +#define cc_scene_RangedDirectionalLight_illuminanceHDR_get(self_) self_->getIlluminanceHDR() +#define cc_scene_RangedDirectionalLight_illuminanceHDR_set(self_, val_) self_->setIlluminanceHDR(val_) + + +#define cc_scene_RangedDirectionalLight_illuminanceLDR_get(self_) self_->getIlluminanceLDR() +#define cc_scene_RangedDirectionalLight_illuminanceLDR_set(self_, val_) self_->setIlluminanceLDR(val_) + + +#define cc_scene_Camera_iso_get(self_) self_->getIso() +#define cc_scene_Camera_iso_set(self_, val_) self_->setIso(val_) + + +#define cc_scene_Camera_isoValue_get(self_) self_->getIsoValue() + + +#define cc_scene_Camera_ec_get(self_) self_->getEc() +#define cc_scene_Camera_ec_set(self_, val_) self_->setEc(val_) + + +#define cc_scene_Camera_exposure_get(self_) self_->getExposure() + + +#define cc_scene_Camera_shutter_get(self_) self_->getShutter() +#define cc_scene_Camera_shutter_set(self_, val_) self_->setShutter(val_) + + +#define cc_scene_Camera_shutterValue_get(self_) self_->getShutterValue() + + +#define cc_scene_Camera_apertureValue_get(self_) self_->getApertureValue() + + +#define cc_scene_Camera_width_get(self_) self_->getWidth() + + +#define cc_scene_Camera_height_get(self_) self_->getHeight() + + +#define cc_scene_Camera_aspect_get(self_) self_->getAspect() + + +#define cc_scene_Camera_scene_get(self_) self_->getScene() + + +#define cc_scene_Camera_name_get(self_) self_->getName() + + +#define cc_scene_Camera_window_get(self_) self_->getWindow() +#define cc_scene_Camera_window_set(self_, val_) self_->setWindow(val_) + + +#define cc_scene_Camera_forward_get(self_) self_->getForward() +#define cc_scene_Camera_forward_set(self_, val_) self_->setForward(val_) + + +#define cc_scene_Camera_aperture_get(self_) self_->getAperture() +#define cc_scene_Camera_aperture_set(self_, val_) self_->setAperture(val_) + + +#define cc_scene_Camera_position_get(self_) self_->getPosition() +#define cc_scene_Camera_position_set(self_, val_) self_->setPosition(val_) + + +#define cc_scene_Camera_projectionType_get(self_) self_->getProjectionType() +#define cc_scene_Camera_projectionType_set(self_, val_) self_->setProjectionType(val_) + + +#define cc_scene_Camera_fovAxis_get(self_) self_->getFovAxis() +#define cc_scene_Camera_fovAxis_set(self_, val_) self_->setFovAxis(val_) + + +#define cc_scene_Camera_fov_get(self_) self_->getFov() +#define cc_scene_Camera_fov_set(self_, val_) self_->setFov(val_) + + +#define cc_scene_Camera_nearClip_get(self_) self_->getNearClip() +#define cc_scene_Camera_nearClip_set(self_, val_) self_->setNearClip(val_) + + +#define cc_scene_Camera_farClip_get(self_) self_->getFarClip() +#define cc_scene_Camera_farClip_set(self_, val_) self_->setFarClip(val_) + + +#define cc_scene_Camera_viewport_get(self_) self_->getViewport() +#define cc_scene_Camera_viewport_set(self_, val_) self_->setViewport(val_) + + +#define cc_scene_Camera_orthoHeight_get(self_) self_->getOrthoHeight() +#define cc_scene_Camera_orthoHeight_set(self_, val_) self_->setOrthoHeight(val_) + + +#define cc_scene_Camera_clearColor_get(self_) self_->getClearColor() +#define cc_scene_Camera_clearColor_set(self_, val_) self_->setClearColor(val_) + + +#define cc_scene_Camera_clearDepth_get(self_) self_->getClearDepth() +#define cc_scene_Camera_clearDepth_set(self_, val_) self_->setClearDepth(val_) + + +#define cc_scene_Camera_clearFlag_get(self_) self_->getClearFlag() +#define cc_scene_Camera_clearFlag_set(self_, val_) self_->setClearFlag(val_) + + +#define cc_scene_Camera_clearStencil_get(self_) self_->getClearStencil() +#define cc_scene_Camera_clearStencil_set(self_, val_) self_->setClearStencil(val_) + + +#define cc_scene_Camera_enabled_get(self_) self_->isEnabled() +#define cc_scene_Camera_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Camera_exposure_get(self_) self_->getExposure() + + +#define cc_scene_Camera_frustum_get(self_) self_->getFrustum() +#define cc_scene_Camera_frustum_set(self_, val_) self_->setFrustum(val_) + + +#define cc_scene_Camera_isWindowSize_get(self_) self_->isWindowSize() +#define cc_scene_Camera_isWindowSize_set(self_, val_) self_->setWindowSize(val_) + + +#define cc_scene_Camera_priority_get(self_) self_->getPriority() +#define cc_scene_Camera_priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_scene_Camera_screenScale_get(self_) self_->getScreenScale() +#define cc_scene_Camera_screenScale_set(self_, val_) self_->setScreenScale(val_) + + +#define cc_scene_Camera_visibility_get(self_) self_->getVisibility() +#define cc_scene_Camera_visibility_set(self_, val_) self_->setVisibility(val_) + + +#define cc_scene_Camera_node_get(self_) self_->getNode() +#define cc_scene_Camera_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_Camera_surfaceTransform_get(self_) self_->getSurfaceTransform() + + +#define cc_scene_Camera_geometryRenderer_get(self_) self_->getGeometryRenderer() + + +#define cc_scene_Camera_systemWindowId_get(self_) self_->getSystemWindowId() + + +#define cc_scene_Camera_cameraUsage_get(self_) self_->getCameraUsage() +#define cc_scene_Camera_cameraUsage_set(self_, val_) self_->setCameraUsage(val_) + + +#define cc_scene_Camera_trackingType_get(self_) self_->getTrackingType() +#define cc_scene_Camera_trackingType_set(self_, val_) self_->setTrackingType(val_) + + +#define cc_scene_Camera_cameraType_get(self_) self_->getCameraType() +#define cc_scene_Camera_cameraType_set(self_, val_) self_->setCameraType(val_) + + +#define cc_scene_Camera_cameraId_get(self_) self_->getCameraId() + + +#define cc_scene_RenderScene_name_get(self_) self_->getName() + + +#define cc_scene_RenderScene_cameras_get(self_) self_->getCameras() + + +#define cc_scene_RenderScene_sphereLights_get(self_) self_->getSphereLights() + + +#define cc_scene_RenderScene_spotLights_get(self_) self_->getSpotLights() + + +#define cc_scene_RenderScene_pointLights_get(self_) self_->getPointLights() + + +#define cc_scene_RenderScene_rangedDirLights_get(self_) self_->getRangedDirLights() + + +#define cc_scene_RenderScene_models_get(self_) self_->getModels() + + +#define cc_scene_RenderScene_lodGroups_get(self_) self_->getLODGroups() + + +#define cc_scene_Skybox_model_get(self_) self_->getModel() + + +#define cc_scene_Skybox_enabled_get(self_) self_->isEnabled() +#define cc_scene_Skybox_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Skybox_useHDR_get(self_) self_->isUseHDR() +#define cc_scene_Skybox_useHDR_set(self_, val_) self_->setUseHDR(val_) + + +#define cc_scene_Skybox_useIBL_get(self_) self_->isUseIBL() +#define cc_scene_Skybox_useIBL_set(self_, val_) self_->setUseIBL(val_) + + +#define cc_scene_Skybox_useDiffuseMap_get(self_) self_->isUseDiffuseMap() +#define cc_scene_Skybox_useDiffuseMap_set(self_, val_) self_->setUseDiffuseMap(val_) + + +#define cc_scene_Skybox_isRGBE_get(self_) self_->isRGBE() + + +#define cc_scene_Skybox_envmap_get(self_) self_->getEnvmap() +#define cc_scene_Skybox_envmap_set(self_, val_) self_->setEnvmap(val_) + + +#define cc_scene_Skybox_diffuseMap_get(self_) self_->getDiffuseMap() +#define cc_scene_Skybox_diffuseMap_set(self_, val_) self_->setDiffuseMap(val_) + + +#define cc_scene_Fog_enabled_get(self_) self_->isEnabled() +#define cc_scene_Fog_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Fog_accurate_get(self_) self_->isAccurate() +#define cc_scene_Fog_accurate_set(self_, val_) self_->setAccurate(val_) + + +#define cc_scene_Fog_fogColor_get(self_) self_->getFogColor() +#define cc_scene_Fog_fogColor_set(self_, val_) self_->setFogColor(val_) + + +#define cc_scene_Fog_type_get(self_) self_->getType() +#define cc_scene_Fog_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Fog_fogDensity_get(self_) self_->getFogDensity() +#define cc_scene_Fog_fogDensity_set(self_, val_) self_->setFogDensity(val_) + + +#define cc_scene_Fog_fogStart_get(self_) self_->getFogStart() +#define cc_scene_Fog_fogStart_set(self_, val_) self_->setFogStart(val_) + + +#define cc_scene_Fog_fogEnd_get(self_) self_->getFogEnd() +#define cc_scene_Fog_fogEnd_set(self_, val_) self_->setFogEnd(val_) + + +#define cc_scene_Fog_fogAtten_get(self_) self_->getFogAtten() +#define cc_scene_Fog_fogAtten_set(self_, val_) self_->setFogAtten(val_) + + +#define cc_scene_Fog_fogTop_get(self_) self_->getFogTop() +#define cc_scene_Fog_fogTop_set(self_, val_) self_->setFogTop(val_) + + +#define cc_scene_Fog_fogRange_get(self_) self_->getFogRange() +#define cc_scene_Fog_fogRange_set(self_, val_) self_->setFogRange(val_) + + +#define cc_scene_Fog_colorArray_get(self_) self_->getColorArray() + + +#define cc_scene_Skin_enabled_get(self_) self_->isEnabled() +#define cc_scene_Skin_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Skin_blurRadius_get(self_) self_->getBlurRadius() +#define cc_scene_Skin_blurRadius_set(self_, val_) self_->setBlurRadius(val_) + + +#define cc_scene_Skin_sssIntensity_get(self_) self_->getSSSIntensity() +#define cc_scene_Skin_sssIntensity_set(self_, val_) self_->setSSSIntensity(val_) + + +#define cc_scene_PostSettings_toneMappingType_get(self_) self_->getToneMappingType() +#define cc_scene_PostSettings_toneMappingType_set(self_, val_) self_->setToneMappingType(val_) + + +#define cc_scene_Model_scene_get(self_) self_->getScene() +#define cc_scene_Model_scene_set(self_, val_) self_->setScene(val_) + + +#define cc_scene_Model__subModels_get(self_) self_->getSubModels() + + +#define cc_scene_Model_subModels_get(self_) self_->getSubModels() + + +#define cc_scene_Model_inited_get(self_) self_->isInited() + + +#define cc_scene_Model__localDataUpdated_get(self_) self_->isLocalDataUpdated() +#define cc_scene_Model__localDataUpdated_set(self_, val_) self_->setLocalDataUpdated(val_) + + +#define cc_scene_Model__worldBounds_get(self_) self_->getWorldBounds() +#define cc_scene_Model__worldBounds_set(self_, val_) self_->setWorldBounds(val_) + + +#define cc_scene_Model_worldBounds_get(self_) self_->getWorldBounds() +#define cc_scene_Model_worldBounds_set(self_, val_) self_->setWorldBounds(val_) + + +#define cc_scene_Model__modelBounds_get(self_) self_->getModelBounds() +#define cc_scene_Model__modelBounds_set(self_, val_) self_->setModelBounds(val_) + + +#define cc_scene_Model_modelBounds_get(self_) self_->getModelBounds() +#define cc_scene_Model_modelBounds_set(self_, val_) self_->setModelBounds(val_) + + +#define cc_scene_Model_worldBoundBuffer_get(self_) self_->getWorldBoundBuffer() +#define cc_scene_Model_worldBoundBuffer_set(self_, val_) self_->setWorldBoundBuffer(val_) + + +#define cc_scene_Model_localBuffer_get(self_) self_->getLocalBuffer() +#define cc_scene_Model_localBuffer_set(self_, val_) self_->setLocalBuffer(val_) + + +#define cc_scene_Model_updateStamp_get(self_) self_->getUpdateStamp() + + +#define cc_scene_Model_receiveShadow_get(self_) self_->isReceiveShadow() +#define cc_scene_Model_receiveShadow_set(self_, val_) self_->setReceiveShadow(val_) + + +#define cc_scene_Model_castShadow_get(self_) self_->isCastShadow() +#define cc_scene_Model_castShadow_set(self_, val_) self_->setCastShadow(val_) + + +#define cc_scene_Model_shadowBias_get(self_) self_->getShadowBias() +#define cc_scene_Model_shadowBias_set(self_, val_) self_->setShadowBias(val_) + + +#define cc_scene_Model_shadowNormalBias_get(self_) self_->getShadowNormalBias() +#define cc_scene_Model_shadowNormalBias_set(self_, val_) self_->setShadowNormalBias(val_) + + +#define cc_scene_Model_node_get(self_) self_->getNode() +#define cc_scene_Model_node_set(self_, val_) self_->setNode(val_) + + +#define cc_scene_Model_transform_get(self_) self_->getTransform() +#define cc_scene_Model_transform_set(self_, val_) self_->setTransform(val_) + + +#define cc_scene_Model_visFlags_get(self_) self_->getVisFlags() +#define cc_scene_Model_visFlags_set(self_, val_) self_->setVisFlags(val_) + + +#define cc_scene_Model_enabled_get(self_) self_->isEnabled() +#define cc_scene_Model_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Model_type_get(self_) self_->getType() +#define cc_scene_Model_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Model_isDynamicBatching_get(self_) self_->isDynamicBatching() +#define cc_scene_Model_isDynamicBatching_set(self_, val_) self_->setDynamicBatching(val_) + + +#define cc_scene_Model_priority_get(self_) self_->getPriority() +#define cc_scene_Model_priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_scene_Model_tetrahedronIndex_get(self_) self_->getTetrahedronIndex() +#define cc_scene_Model_tetrahedronIndex_set(self_, val_) self_->setTetrahedronIndex(val_) + + +#define cc_scene_Model_useLightProbe_get(self_) self_->getUseLightProbe() +#define cc_scene_Model_useLightProbe_set(self_, val_) self_->setUseLightProbe(val_) + + +#define cc_scene_Model_bakeToReflectionProbe_get(self_) self_->getBakeToReflectionProbe() +#define cc_scene_Model_bakeToReflectionProbe_set(self_, val_) self_->setBakeToReflectionProbe(val_) + + +#define cc_scene_Model_reflectionProbeType_get(self_) self_->getReflectionProbeType() +#define cc_scene_Model_reflectionProbeType_set(self_, val_) self_->setReflectionProbeType(val_) + + +#define cc_scene_Model_receiveDirLight_get(self_) self_->isReceiveDirLight() +#define cc_scene_Model_receiveDirLight_set(self_, val_) self_->setReceiveDirLight(val_) + + +#define cc_scene_Model_reflectionProbeId_get(self_) self_->getReflectionProbeId() +#define cc_scene_Model_reflectionProbeId_set(self_, val_) self_->setReflectionProbeId(val_) + + +#define cc_scene_Model_reflectionProbeBlendId_get(self_) self_->getReflectionProbeBlendId() +#define cc_scene_Model_reflectionProbeBlendId_set(self_, val_) self_->setReflectionProbeBlendId(val_) + + +#define cc_scene_Model_reflectionProbeBlendWeight_get(self_) self_->getReflectionProbeBlendWeight() +#define cc_scene_Model_reflectionProbeBlendWeight_set(self_, val_) self_->setReflectionProbeBlendWeight(val_) + + +#define cc_scene_SubModel_passes_get(self_) self_->getPasses() +#define cc_scene_SubModel_passes_set(self_, val_) self_->setPasses(val_) + + +#define cc_scene_SubModel_shaders_get(self_) self_->getShaders() +#define cc_scene_SubModel_shaders_set(self_, val_) self_->setShaders(val_) + + +#define cc_scene_SubModel_subMesh_get(self_) self_->getSubMesh() +#define cc_scene_SubModel_subMesh_set(self_, val_) self_->setSubMesh(val_) + + +#define cc_scene_SubModel_priority_get(self_) self_->getPriority() +#define cc_scene_SubModel_priority_set(self_, val_) self_->setPriority(val_) + + +#define cc_scene_SubModel_inputAssembler_get(self_) self_->getInputAssembler() +#define cc_scene_SubModel_inputAssembler_set(self_, val_) self_->setInputAssembler(val_) + + +#define cc_scene_SubModel_descriptorSet_get(self_) self_->getDescriptorSet() +#define cc_scene_SubModel_descriptorSet_set(self_, val_) self_->setDescriptorSet(val_) + + +#define cc_scene_SubModel_patches_get(self_) self_->getPatches() + + +#define cc_scene_ShadowsInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_ShadowsInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_ShadowsInfo_type_get(self_) self_->getType() +#define cc_scene_ShadowsInfo_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_ShadowsInfo_shadowColor_get(self_) self_->getShadowColor() +#define cc_scene_ShadowsInfo_shadowColor_set(self_, val_) self_->setShadowColor(val_) + + +#define cc_scene_ShadowsInfo_planeDirection_get(self_) self_->getPlaneDirection() +#define cc_scene_ShadowsInfo_planeDirection_set(self_, val_) self_->setPlaneDirection(val_) + + +#define cc_scene_ShadowsInfo_planeHeight_get(self_) self_->getPlaneHeight() +#define cc_scene_ShadowsInfo_planeHeight_set(self_, val_) self_->setPlaneHeight(val_) + + +#define cc_scene_ShadowsInfo_planeBias_get(self_) self_->getPlaneBias() +#define cc_scene_ShadowsInfo_planeBias_set(self_, val_) self_->setPlaneBias(val_) + + +#define cc_scene_ShadowsInfo_maxReceived_get(self_) self_->getMaxReceived() +#define cc_scene_ShadowsInfo_maxReceived_set(self_, val_) self_->setMaxReceived(val_) + + +#define cc_scene_ShadowsInfo_shadowMapSize_get(self_) self_->getShadowMapSize() +#define cc_scene_ShadowsInfo_shadowMapSize_set(self_, val_) self_->setShadowMapSize(val_) + + +#define cc_scene_Shadows_enabled_get(self_) self_->isEnabled() +#define cc_scene_Shadows_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_Shadows_type_get(self_) self_->getType() +#define cc_scene_Shadows_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_Shadows_normal_get(self_) self_->getNormal() +#define cc_scene_Shadows_normal_set(self_, val_) self_->setNormal(val_) + + +#define cc_scene_Shadows_distance_get(self_) self_->getDistance() +#define cc_scene_Shadows_distance_set(self_, val_) self_->setDistance(val_) + + +#define cc_scene_Shadows_planeBias_get(self_) self_->getPlaneBias() +#define cc_scene_Shadows_planeBias_set(self_, val_) self_->setPlaneBias(val_) + + +#define cc_scene_Shadows_shadowColor_get(self_) self_->getShadowColor() +#define cc_scene_Shadows_shadowColor_set(self_, val_) self_->setShadowColor(val_) + + +#define cc_scene_Shadows_maxReceived_get(self_) self_->getMaxReceived() +#define cc_scene_Shadows_maxReceived_set(self_, val_) self_->setMaxReceived(val_) + + +#define cc_scene_Shadows_size_get(self_) self_->getSize() +#define cc_scene_Shadows_size_set(self_, val_) self_->setSize(val_) + + +#define cc_scene_Shadows_shadowMapDirty_get(self_) self_->isShadowMapDirty() +#define cc_scene_Shadows_shadowMapDirty_set(self_, val_) self_->setShadowMapDirty(val_) + + +#define cc_scene_Shadows_matLight_get(self_) self_->getMatLight() + + +#define cc_scene_Shadows_material_get(self_) self_->getMaterial() + + +#define cc_scene_Shadows_instancingMaterial_get(self_) self_->getInstancingMaterial() + + +#define cc_scene_AmbientInfo_skyColor_set(self_, val_) self_->setSkyColor(val_) + + +#define cc_scene_AmbientInfo_skyIllum_get(self_) self_->getSkyIllum() +#define cc_scene_AmbientInfo_skyIllum_set(self_, val_) self_->setSkyIllum(val_) + + +#define cc_scene_AmbientInfo_groundAlbedo_set(self_, val_) self_->setGroundAlbedo(val_) + + +#define cc_scene_AmbientInfo__skyColor_get(self_) self_->getSkyColorHDR() +#define cc_scene_AmbientInfo__skyColor_set(self_, val_) self_->setSkyColorHDR(val_) + + +#define cc_scene_AmbientInfo__skyIllum_get(self_) self_->getSkyIllumHDR() +#define cc_scene_AmbientInfo__skyIllum_set(self_, val_) self_->setSkyIllumHDR(val_) + + +#define cc_scene_AmbientInfo__groundAlbedo_get(self_) self_->getGroundAlbedoHDR() +#define cc_scene_AmbientInfo__groundAlbedo_set(self_, val_) self_->setGroundAlbedoHDR(val_) + + +#define cc_scene_AmbientInfo_skyColorLDR_get(self_) self_->getSkyColorLDR() + + +#define cc_scene_AmbientInfo_groundAlbedoLDR_get(self_) self_->getGroundAlbedoLDR() + + +#define cc_scene_AmbientInfo_skyIllumLDR_get(self_) self_->getSkyIllumLDR() + + +#define cc_scene_AmbientInfo_skyLightingColor_get(self_) self_->getSkyLightingColor() +#define cc_scene_AmbientInfo_skyLightingColor_set(self_, val_) self_->setSkyLightingColor(val_) + + +#define cc_scene_AmbientInfo_groundLightingColor_get(self_) self_->getGroundLightingColor() +#define cc_scene_AmbientInfo_groundLightingColor_set(self_, val_) self_->setGroundLightingColor(val_) + + +#define cc_scene_FogInfo_type_get(self_) self_->getType() +#define cc_scene_FogInfo_type_set(self_, val_) self_->setType(val_) + + +#define cc_scene_FogInfo_fogColor_get(self_) self_->getFogColor() +#define cc_scene_FogInfo_fogColor_set(self_, val_) self_->setFogColor(val_) + + +#define cc_scene_FogInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_FogInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_FogInfo_accurate_get(self_) self_->isAccurate() +#define cc_scene_FogInfo_accurate_set(self_, val_) self_->setAccurate(val_) + + +#define cc_scene_FogInfo_fogDensity_get(self_) self_->getFogDensity() +#define cc_scene_FogInfo_fogDensity_set(self_, val_) self_->setFogDensity(val_) + + +#define cc_scene_FogInfo_fogStart_get(self_) self_->getFogStart() +#define cc_scene_FogInfo_fogStart_set(self_, val_) self_->setFogStart(val_) + + +#define cc_scene_FogInfo_fogEnd_get(self_) self_->getFogEnd() +#define cc_scene_FogInfo_fogEnd_set(self_, val_) self_->setFogEnd(val_) + + +#define cc_scene_FogInfo_fogAtten_get(self_) self_->getFogAtten() +#define cc_scene_FogInfo_fogAtten_set(self_, val_) self_->setFogAtten(val_) + + +#define cc_scene_FogInfo_fogTop_get(self_) self_->getFogTop() +#define cc_scene_FogInfo_fogTop_set(self_, val_) self_->setFogTop(val_) + + +#define cc_scene_FogInfo_fogRange_get(self_) self_->getFogRange() +#define cc_scene_FogInfo_fogRange_set(self_, val_) self_->setFogRange(val_) + + +#define cc_scene_SkyboxInfo__envmap_get(self_) self_->getEnvmapForJS() +#define cc_scene_SkyboxInfo__envmap_set(self_, val_) self_->setEnvmapForJS(val_) + + +#define cc_scene_SkyboxInfo_applyDiffuseMap_get(self_) self_->isApplyDiffuseMap() +#define cc_scene_SkyboxInfo_applyDiffuseMap_set(self_, val_) self_->setApplyDiffuseMap(val_) + + +#define cc_scene_SkyboxInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_SkyboxInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_SkyboxInfo_useIBL_get(self_) self_->isUseIBL() +#define cc_scene_SkyboxInfo_useIBL_set(self_, val_) self_->setUseIBL(val_) + + +#define cc_scene_SkyboxInfo_useHDR_get(self_) self_->isUseHDR() +#define cc_scene_SkyboxInfo_useHDR_set(self_, val_) self_->setUseHDR(val_) + + +#define cc_scene_SkyboxInfo_envmap_get(self_) self_->getEnvmap() +#define cc_scene_SkyboxInfo_envmap_set(self_, val_) self_->setEnvmap(val_) + + +#define cc_scene_SkyboxInfo_diffuseMap_get(self_) self_->getDiffuseMap() +#define cc_scene_SkyboxInfo_diffuseMap_set(self_, val_) self_->setDiffuseMap(val_) + + +#define cc_scene_SkyboxInfo_reflectionMap_get(self_) self_->getReflectionMap() +#define cc_scene_SkyboxInfo_reflectionMap_set(self_, val_) self_->setReflectionMap(val_) + + +#define cc_scene_SkyboxInfo_skyboxMaterial_get(self_) self_->getSkyboxMaterial() +#define cc_scene_SkyboxInfo_skyboxMaterial_set(self_, val_) self_->setSkyboxMaterial(val_) + + +#define cc_scene_SkyboxInfo_rotationAngle_get(self_) self_->getRotationAngle() +#define cc_scene_SkyboxInfo_rotationAngle_set(self_, val_) self_->setRotationAngle(val_) + + +#define cc_scene_SkyboxInfo_envLightingType_get(self_) self_->getEnvLightingType() +#define cc_scene_SkyboxInfo_envLightingType_set(self_, val_) self_->setEnvLightingType(val_) + + +#define cc_scene_OctreeInfo_enabled_get(self_) self_->isEnabled() +#define cc_scene_OctreeInfo_enabled_set(self_, val_) self_->setEnabled(val_) + + +#define cc_scene_OctreeInfo_minPos_get(self_) self_->getMinPos() +#define cc_scene_OctreeInfo_minPos_set(self_, val_) self_->setMinPos(val_) + + +#define cc_scene_OctreeInfo_maxPos_get(self_) self_->getMaxPos() +#define cc_scene_OctreeInfo_maxPos_set(self_, val_) self_->setMaxPos(val_) + + +#define cc_scene_OctreeInfo_depth_get(self_) self_->getDepth() +#define cc_scene_OctreeInfo_depth_set(self_, val_) self_->setDepth(val_) + + +#define cc_scene_PostSettingsInfo_toneMappingType_get(self_) self_->getToneMappingType() +#define cc_scene_PostSettingsInfo_toneMappingType_set(self_, val_) self_->setToneMappingType(val_) + + +#define cc_Scene_autoReleaseAssets_get(self_) self_->isAutoReleaseAssets() +#define cc_Scene_autoReleaseAssets_set(self_, val_) self_->setAutoReleaseAssets(val_) + + +#define cc_scene_ReflectionProbe_probeType_get(self_) self_->getProbeType() +#define cc_scene_ReflectionProbe_probeType_set(self_, val_) self_->setProbeType(val_) + + +#define cc_scene_ReflectionProbe_resolution_get(self_) self_->getResolution() +#define cc_scene_ReflectionProbe_resolution_set(self_, val_) self_->setResolution(val_) + + +#define cc_scene_ReflectionProbe_clearFlag_get(self_) self_->getClearFlag() +#define cc_scene_ReflectionProbe_clearFlag_set(self_, val_) self_->setClearFlag(val_) + + +#define cc_scene_ReflectionProbe_backgroundColor_get(self_) self_->getBackgroundColor() +#define cc_scene_ReflectionProbe_backgroundColor_set(self_, val_) self_->setBackgroundColor(val_) + + +#define cc_scene_ReflectionProbe_visibility_get(self_) self_->getVisibility() +#define cc_scene_ReflectionProbe_visibility_set(self_, val_) self_->setVisibility(val_) + + +#define cc_scene_ReflectionProbe_size_get(self_) self_->getBoudingSize() +#define cc_scene_ReflectionProbe_size_set(self_, val_) self_->setBoudingSize(val_) + + +#define cc_scene_ReflectionProbe_boundingBox_get(self_) self_->getBoundingBox() + + +#define cc_scene_ReflectionProbe_previewSphere_get(self_) self_->getPreviewSphere() +#define cc_scene_ReflectionProbe_previewSphere_set(self_, val_) self_->setPreviewSphere(val_) + + +#define cc_scene_ReflectionProbe_previewPlane_get(self_) self_->getPreviewPlane() +#define cc_scene_ReflectionProbe_previewPlane_set(self_, val_) self_->setPreviewPlane(val_) + + +#define cc_scene_ReflectionProbe_bakedCubeTextures_get(self_) self_->getBakedCubeTextures() + + +#define cc_scene_ReflectionProbe_cubemap_get(self_) self_->getCubeMap() +#define cc_scene_ReflectionProbe_cubemap_set(self_, val_) self_->setCubeMap(val_) + + +#define cc_scene_ReflectionProbe_node_get(self_) self_->getNode() + + +#define cc_scene_ReflectionProbe_realtimePlanarTexture_get(self_) self_->getRealtimePlanarTexture() + + +#define cc_scene_ReflectionProbe_camera_get(self_) self_->getCamera() + + +#define cc_SceneGlobals_bakedWithStationaryMainLight_get(self_) self_->getBakedWithStationaryMainLight() +#define cc_SceneGlobals_bakedWithStationaryMainLight_set(self_, val_) self_->setBakedWithStationaryMainLight(val_) + + +#define cc_SceneGlobals_bakedWithHighpLightmap_get(self_) self_->getBakedWithHighpLightmap() +#define cc_SceneGlobals_bakedWithHighpLightmap_set(self_, val_) self_->setBakedWithHighpLightmap(val_) + + + +static bool js_cc_hasFlag__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + cc::TransformBit arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasFlag(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAnyFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + cc::TransformBit arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAnyFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAllFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + cc::TransformBit arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAllFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_addFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit *arg1 = 0 ; + cc::TransformBit arg2 ; + cc::TransformBit temp1 ; + cc::TransformBit result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::TransformBit)cc::addFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_removeFlags__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit *arg1 = 0 ; + cc::TransformBit arg2 ; + cc::TransformBit temp1 ; + cc::TransformBit result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::TransformBit)cc::removeFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_toNumber__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::TransformBit arg1 ; + std::underlying_type_t< cc::TransformBit > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::toNumber(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::Class* __jsb_cc_Layers_class = nullptr; +se::Object* __jsb_cc_Layers_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Layers) + +static bool js_cc_Layers_makeMaskInclude_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< uint32_t > *arg1 = 0 ; + ccstd::vector< uint32_t > temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::Layers::makeMaskInclude((ccstd::vector< uint32_t > const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Layers_makeMaskInclude_static) + +static bool js_cc_Layers_makeMaskExclude_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + ccstd::vector< uint32_t > *arg1 = 0 ; + ccstd::vector< uint32_t > temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::Layers::makeMaskExclude((ccstd::vector< uint32_t > const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Layers_makeMaskExclude_static) + +bool js_register_cc_Layers(se::Object* obj) { + auto* cls = se::Class::create("Layers", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("makeMaskInclude", _SE(js_cc_Layers_makeMaskInclude_static)); + cls->defineStaticFunction("makeMaskExclude", _SE(js_cc_Layers_makeMaskExclude_static)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Layers_proto = cls->getProto(); + __jsb_cc_Layers_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_hasFlag__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + cc::Layers::LayerList arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasFlag(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasFlag(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_hasFlag__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_hasFlag__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_hasFlag) + +static bool js_cc_hasAnyFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + cc::Layers::LayerList arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAnyFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAnyFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_hasAnyFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_hasAnyFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_hasAnyFlags) + +static bool js_cc_hasAllFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + cc::Layers::LayerList arg2 ; + bool result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (bool)cc::hasAllFlags(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_hasAllFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_hasAllFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_hasAllFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_hasAllFlags) + +static bool js_cc_addFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList *arg1 = 0 ; + cc::Layers::LayerList arg2 ; + cc::Layers::LayerList temp1 ; + cc::Layers::LayerList result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Layers::LayerList)cc::addFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_addFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_addFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_addFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_addFlags) + +static bool js_cc_removeFlags__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList *arg1 = 0 ; + cc::Layers::LayerList arg2 ; + cc::Layers::LayerList temp1 ; + cc::Layers::LayerList result; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::Layers::LayerList)cc::removeFlags(*arg1,arg2); + + 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; +} + +static bool js_cc_removeFlags(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_removeFlags__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_removeFlags__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_removeFlags) + +static bool js_cc_toNumber__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Layers::LayerList arg1 ; + std::underlying_type_t< cc::Layers::LayerList > result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::toNumber(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; +} + +static bool js_cc_toNumber(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_toNumber__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_toNumber__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_toNumber) + +se::Class* __jsb_cc_Node_class = nullptr; +se::Object* __jsb_cc_Node_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Node) + +se::Class* __jsb_cc_Node_UserData_class = nullptr; +se::Object* __jsb_cc_Node_UserData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Node_UserData) + +static bool js_delete_cc_Node_UserData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Node_UserData) + +bool js_register_cc_Node_UserData(se::Object* obj) { + auto* cls = se::Class::create({"Node", "UserData"}, obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Node_UserData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Node_UserData_proto = cls->getProto(); + __jsb_cc_Node_UserData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_Node_instantiate_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + cc::Node *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], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Node *)cc::Node::instantiate(arg1,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_Node_instantiate_static) + +static bool js_cc_Node_setScene_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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::Node::setScene(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setScene_static) + +static bool js_cc_Node_resetHasChangedFlags_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::resetChangedFlags(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_resetHasChangedFlags_static) + +static bool js_cc_Node_clearNodeArray_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::clearNodeArray(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_clearNodeArray_static) + +static bool js_cc_Node__incSkewCompCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::_incSkewCompCount(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__incSkewCompCount_static) + +static bool js_cc_Node__decSkewCompCount_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::Node::_decSkewCompCount(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__decSkewCompCount_static) + +static bool js_new_cc_Node__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Node *result; + result = (cc::Node *)new cc::Node(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Node__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::Node *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Node *)new cc::Node((ccstd::string const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Node(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_Node__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_Node__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Node"); + return false; +} +SE_BIND_CTOR(js_new_cc_Node, __jsb_cc_Node_class, js_delete_cc_Node) + +static bool js_delete_cc_Node(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Node) + +static bool js_cc_Node_onPostActivated(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->onPostActivated(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_onPostActivated) + +static bool js_cc_Node_setParent__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool arg3 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2,arg3); + + + return true; +} + +static bool js_cc_Node_setParent__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParent(arg2); + + + return true; +} + +static bool js_cc_Node_setParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Node_setParent__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Node_setParent__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setParent) + +static bool js_cc_Node_modifyParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->modifyParent(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_modifyParent) + +static bool js_cc_Node_getScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Scene *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(s); + if (nullptr == arg1) return true; + result = (cc::Scene *)((cc::Node const *)arg1)->getScene(); + + 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_Node_getScene) + +static bool js_cc_Node_walk__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node::WalkCallback *arg2 = 0 ; + cc::Node::WalkCallback temp2 ; + + arg1 = SE_THIS_OBJECT(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)->walk((cc::Node::WalkCallback const &)*arg2); + + + return true; +} + +static bool js_cc_Node_walk__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node::WalkCallback *arg2 = 0 ; + cc::Node::WalkCallback *arg3 = 0 ; + cc::Node::WalkCallback temp2 ; + cc::Node::WalkCallback temp3 ; + + arg1 = SE_THIS_OBJECT(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)->walk((cc::Node::WalkCallback const &)*arg2,(cc::Node::WalkCallback const &)*arg3); + + + return true; +} + +static bool js_cc_Node_walk(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_walk__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_Node_walk__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_walk) + +static bool js_cc_Node_destroyAllChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyAllChildren(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_destroyAllChildren) + +static bool js_cc_Node__updateSiblingIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateSiblingIndex(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__updateSiblingIndex) + +static bool js_cc_Node_addChild(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addChild(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_addChild) + +static bool js_cc_Node_removeChild(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((cc::Node const *)arg1)->removeChild(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_removeChild) + +static bool js_cc_Node_removeFromParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeFromParent(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_removeFromParent) + +static bool js_cc_Node_removeAllChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeAllChildren(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_removeAllChildren) + +static bool js_cc_Node_isChildOf(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)((cc::Node const *)arg1)->isChildOf(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_isChildOf) + +static bool js_cc_Node_setActive(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setActive(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setActive) + +static bool js_cc_Node_setSiblingIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSiblingIndex(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setSiblingIndex) + +static bool js_cc_Node_isActive(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Node const *)arg1)->isActive(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_isActive) + +static bool js_cc_Node_getParent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *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(s); + if (nullptr == arg1) return true; + result = (cc::Node *)((cc::Node const *)arg1)->getParent(); + + 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_Node_getParent) + +static bool js_cc_Node_getChildByUuid(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Node *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(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::Node *)((cc::Node const *)arg1)->getChildByUuid((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_Node_getChildByUuid) + +static bool js_cc_Node_getChildByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Node *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(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::Node *)((cc::Node const *)arg1)->getChildByName((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_Node_getChildByName) + +static bool js_cc_Node_getChildByPath(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::Node *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(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::Node *)((cc::Node const *)arg1)->getChildByPath((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_Node_getChildByPath) + +static bool js_cc_Node_getSiblingIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + index_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Node const *)arg1)->getSiblingIndex(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_getSiblingIndex) + +static bool js_cc_Node_insertChild(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + index_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->insertChild(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_insertChild) + +static bool js_cc_Node_invalidateChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::TransformBit arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->invalidateChildren(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_invalidateChildren) + +static bool js_cc_Node_translate__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::NodeSpace arg3 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->translate((cc::Vec3 const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_Node_translate__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->translate((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_translate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Node_translate__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Node_translate__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_translate) + +static bool js_cc_Node_lookAt__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + arg1 = SE_THIS_OBJECT(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)->lookAt((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3); + + + return true; +} + +static bool js_cc_Node_lookAt__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->lookAt((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_lookAt(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_Node_lookAt__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Node_lookAt__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_lookAt) + +static bool js_cc_Node_pauseSystemEvents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->pauseSystemEvents(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_pauseSystemEvents) + +static bool js_cc_Node_resumeSystemEvents(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->resumeSystemEvents(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_resumeSystemEvents) + +static bool js_cc_Node_getPathInHierarchy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Node const *)arg1)->getPathInHierarchy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_Node_getPathInHierarchy) + +static bool js_cc_Node_setPositionInternal__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + bool arg4 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPositionInternal(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setPositionInternal__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + bool arg5 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPositionInternal(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Node_setPositionInternal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Node_setPositionInternal__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Node_setPositionInternal__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setPositionInternal) + +static bool js_cc_Node_setPositionForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPositionForJS(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setPositionForJS) + +static bool js_cc_Node_setRotationInternal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + bool arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRotationInternal(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setRotationInternal) + +static bool js_cc_Node_setRotationForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setRotationForJS(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setRotationForJS) + +static bool js_cc_Node_setEulerAngles(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEulerAngles((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setEulerAngles) + +static bool js_cc_Node_setRotationFromEulerForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setRotationFromEulerForJS(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setRotationFromEulerForJS) + +static bool js_cc_Node_setScaleInternal__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + bool arg4 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setScaleInternal(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setScaleInternal__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + bool arg5 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setScaleInternal(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Node_setScaleInternal(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_Node_setScaleInternal__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Node_setScaleInternal__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setScaleInternal) + +static bool js_cc_Node_setScaleForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setScaleForJS(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setScaleForJS) + +static bool js_cc_Node_inverseTransformPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (arg1)->inverseTransformPoint((cc::Vec3 const &)*arg2); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_Node_inverseTransformPoint) + +static bool js_cc_Node_setWorldPosition__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldPosition((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_setWorldPosition__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldPosition(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setWorldPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_setWorldPosition__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_Node_setWorldPosition__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setWorldPosition) + +static bool js_cc_Node_setWorldRotation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Quaternion *arg2 = 0 ; + cc::Quaternion temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldRotation((cc::Quaternion const &)*arg2); + + + return true; +} + +static bool js_cc_Node_setWorldRotation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldRotation(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_Node_setWorldRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_setWorldRotation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_Node_setWorldRotation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setWorldRotation) + +static bool js_cc_Node_setWorldScale__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldScale((cc::Vec3 const &)*arg2); + + + return true; +} + +static bool js_cc_Node_setWorldScale__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setWorldScale(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_Node_setWorldScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Node_setWorldScale__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_Node_setWorldScale__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Node_setWorldScale) + +static bool js_cc_Node_setWorldRotationFromEuler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setWorldRotationFromEuler(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setWorldRotationFromEuler) + +static bool js_cc_Node_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_updateWorldTransform) + +static bool js_cc_Node_setForward(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setForward((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setForward) + +static bool js_cc_Node_isStatic(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Node const *)arg1)->isStatic(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_isStatic) + +static bool js_cc_Node_setStatic(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setStatic(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setStatic) + +static bool js_cc_Node_setLayer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setLayer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_setLayer) + +static bool js_cc_Node_getLayer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::Node const *)arg1)->getLayer(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node_getLayer) + +static bool js_cc_Node__setChildren(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::Node > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::Node > > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->_setChildren((ccstd::vector< cc::IntrusivePtr< cc::Node > > &&)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__setChildren) + +static bool js_cc_Node__getLocalOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::Node const *)arg1)->_getLocalOpacity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__getLocalOpacity) + +static bool js_cc_Node__getFinalOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::Node const *)arg1)->_getFinalOpacity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__getFinalOpacity) + +static bool js_cc_Node__setFinalOpacity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_setFinalOpacity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__setFinalOpacity) + +static bool js_cc_Node__isColorDirty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::Node const *)arg1)->_isColorDirty(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__isColorDirty) + +static bool js_cc_Node__setColorDirty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->_setColorDirty(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__setColorDirty) + +static bool js_cc_Node__onPreDestroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onPreDestroy(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__onPreDestroy) + +static bool js_cc_Node__onPreDestroyBase(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->onPreDestroyBase(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Node__onPreDestroyBase) + +static bool js_cc_Node__id_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_id, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__id_set) + +static bool js_cc_Node__id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_id, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_id, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__id_get) + +static bool js_cc_Node__parentInternal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__parentInternal_set) + +static bool js_cc_Node__parentInternal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__parentInternal_get) + +static bool js_cc_Node__mobility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_mobility, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__mobility_set) + +static bool js_cc_Node__mobility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_mobility, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_mobility, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__mobility_get) + +static bool js_cc_Node_uuid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_Node_uuid_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_Node_uuid_get) + +static bool js_cc_Node_angle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Node_angle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_angle_set) + +static bool js_cc_Node_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_Node_angle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_angle_get) + +static bool js_cc_Node_matrix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::Mat4 *arg2 = 0 ; + cc::Mat4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_Node_matrix_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_matrix_set) + +static bool js_cc_Node_hasChangedFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Node_hasChangedFlags_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_hasChangedFlags_set) + +static bool js_cc_Node_hasChangedFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Node_hasChangedFlags_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_hasChangedFlags_get) + +static bool js_cc_Node_flagChangedVersion_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Node_flagChangedVersion_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_flagChangedVersion_get) + +static bool js_cc_Node__persistNode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Node__persistNode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node__persistNode_set) + +static bool js_cc_Node__persistNode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Node__persistNode_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node__persistNode_get) + +static bool js_cc_Node_mobility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + cc::MobilityMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Node_mobility_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_mobility_set) + +static bool js_cc_Node_mobility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + cc::MobilityMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::MobilityMode)cc_Node_mobility_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_Node_mobility_get) + +static bool js_cc_Node_isSkipTransformUpdate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Node *arg1 = (cc::Node *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Node_isSkipTransformUpdate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Node_isSkipTransformUpdate_set) + +static bool js_cc_Node_isSkipTransformUpdate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Node *arg1 = (cc::Node *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Node_isSkipTransformUpdate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Node_isSkipTransformUpdate_get) + +bool js_register_cc_Node(se::Object* obj) { + auto* cls = se::Class::create("Node", obj, __jsb_cc_CCObject_proto, _SE(js_new_cc_Node)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_id", _SE(js_cc_Node__id_get), _SE(js_cc_Node__id_set)); + cls->defineProperty("_parentInternal", _SE(js_cc_Node__parentInternal_get), _SE(js_cc_Node__parentInternal_set)); + cls->defineProperty("_mobility", _SE(js_cc_Node__mobility_get), _SE(js_cc_Node__mobility_set)); + cls->defineProperty("uuid", _SE(js_cc_Node_uuid_get), nullptr); + cls->defineProperty("angle", _SE(js_cc_Node_angle_get), _SE(js_cc_Node_angle_set)); + cls->defineProperty("matrix", nullptr, _SE(js_cc_Node_matrix_set)); + cls->defineProperty("hasChangedFlags", _SE(js_cc_Node_hasChangedFlags_get), _SE(js_cc_Node_hasChangedFlags_set)); + cls->defineProperty("flagChangedVersion", _SE(js_cc_Node_flagChangedVersion_get), nullptr); + cls->defineProperty("_persistNode", _SE(js_cc_Node__persistNode_get), _SE(js_cc_Node__persistNode_set)); + cls->defineProperty("mobility", _SE(js_cc_Node_mobility_get), _SE(js_cc_Node_mobility_set)); + cls->defineProperty("isSkipTransformUpdate", _SE(js_cc_Node_isSkipTransformUpdate_get), _SE(js_cc_Node_isSkipTransformUpdate_set)); + + cls->defineFunction("onPostActivated", _SE(js_cc_Node_onPostActivated)); + cls->defineFunction("setParent", _SE(js_cc_Node_setParent)); + cls->defineFunction("modifyParent", _SE(js_cc_Node_modifyParent)); + cls->defineFunction("getScene", _SE(js_cc_Node_getScene)); + cls->defineFunction("walk", _SE(js_cc_Node_walk)); + cls->defineFunction("destroyAllChildren", _SE(js_cc_Node_destroyAllChildren)); + cls->defineFunction("_updateSiblingIndex", _SE(js_cc_Node__updateSiblingIndex)); + cls->defineFunction("addChild", _SE(js_cc_Node_addChild)); + cls->defineFunction("removeChild", _SE(js_cc_Node_removeChild)); + cls->defineFunction("removeFromParent", _SE(js_cc_Node_removeFromParent)); + cls->defineFunction("removeAllChildren", _SE(js_cc_Node_removeAllChildren)); + cls->defineFunction("isChildOf", _SE(js_cc_Node_isChildOf)); + cls->defineFunction("setActive", _SE(js_cc_Node_setActive)); + cls->defineFunction("setSiblingIndex", _SE(js_cc_Node_setSiblingIndex)); + cls->defineFunction("isActive", _SE(js_cc_Node_isActive)); + cls->defineFunction("getParent", _SE(js_cc_Node_getParent)); + cls->defineFunction("getChildByUuid", _SE(js_cc_Node_getChildByUuid)); + cls->defineFunction("getChildByName", _SE(js_cc_Node_getChildByName)); + cls->defineFunction("getChildByPath", _SE(js_cc_Node_getChildByPath)); + cls->defineFunction("getSiblingIndex", _SE(js_cc_Node_getSiblingIndex)); + cls->defineFunction("insertChild", _SE(js_cc_Node_insertChild)); + cls->defineFunction("invalidateChildren", _SE(js_cc_Node_invalidateChildren)); + cls->defineFunction("translate", _SE(js_cc_Node_translate)); + cls->defineFunction("lookAt", _SE(js_cc_Node_lookAt)); + cls->defineFunction("pauseSystemEvents", _SE(js_cc_Node_pauseSystemEvents)); + cls->defineFunction("resumeSystemEvents", _SE(js_cc_Node_resumeSystemEvents)); + cls->defineFunction("getPathInHierarchy", _SE(js_cc_Node_getPathInHierarchy)); + cls->defineFunction("setPositionInternal", _SE(js_cc_Node_setPositionInternal)); + cls->defineFunction("setPositionForJS", _SE(js_cc_Node_setPositionForJS)); + cls->defineFunction("setRotationInternal", _SE(js_cc_Node_setRotationInternal)); + cls->defineFunction("setRotationForJS", _SE(js_cc_Node_setRotationForJS)); + cls->defineFunction("setEulerAngles", _SE(js_cc_Node_setEulerAngles)); + cls->defineFunction("setRotationFromEulerForJS", _SE(js_cc_Node_setRotationFromEulerForJS)); + cls->defineFunction("setScaleInternal", _SE(js_cc_Node_setScaleInternal)); + cls->defineFunction("setScaleForJS", _SE(js_cc_Node_setScaleForJS)); + cls->defineFunction("inverseTransformPoint", _SE(js_cc_Node_inverseTransformPoint)); + cls->defineFunction("setWorldPosition", _SE(js_cc_Node_setWorldPosition)); + cls->defineFunction("setWorldRotation", _SE(js_cc_Node_setWorldRotation)); + cls->defineFunction("setWorldScale", _SE(js_cc_Node_setWorldScale)); + cls->defineFunction("setWorldRotationFromEuler", _SE(js_cc_Node_setWorldRotationFromEuler)); + cls->defineFunction("updateWorldTransform", _SE(js_cc_Node_updateWorldTransform)); + cls->defineFunction("setForward", _SE(js_cc_Node_setForward)); + cls->defineFunction("isStatic", _SE(js_cc_Node_isStatic)); + cls->defineFunction("setStatic", _SE(js_cc_Node_setStatic)); + cls->defineFunction("setLayer", _SE(js_cc_Node_setLayer)); + cls->defineFunction("getLayer", _SE(js_cc_Node_getLayer)); + cls->defineFunction("_setChildren", _SE(js_cc_Node__setChildren)); + cls->defineFunction("_getLocalOpacity", _SE(js_cc_Node__getLocalOpacity)); + cls->defineFunction("_getFinalOpacity", _SE(js_cc_Node__getFinalOpacity)); + cls->defineFunction("_setFinalOpacity", _SE(js_cc_Node__setFinalOpacity)); + cls->defineFunction("_isColorDirty", _SE(js_cc_Node__isColorDirty)); + cls->defineFunction("_setColorDirty", _SE(js_cc_Node__setColorDirty)); + cls->defineFunction("_onPreDestroy", _SE(js_cc_Node__onPreDestroy)); + cls->defineFunction("_onPreDestroyBase", _SE(js_cc_Node__onPreDestroyBase)); + + + cls->defineStaticFunction("instantiate", _SE(js_cc_Node_instantiate_static)); + cls->defineStaticFunction("setScene", _SE(js_cc_Node_setScene_static)); + cls->defineStaticFunction("resetHasChangedFlags", _SE(js_cc_Node_resetHasChangedFlags_static)); + cls->defineStaticFunction("clearNodeArray", _SE(js_cc_Node_clearNodeArray_static)); + cls->defineStaticFunction("_incSkewCompCount", _SE(js_cc_Node__incSkewCompCount_static)); + cls->defineStaticFunction("_decSkewCompCount", _SE(js_cc_Node__decSkewCompCount_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Node)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Node_proto = cls->getProto(); + __jsb_cc_Node_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Scene_class = nullptr; +se::Object* __jsb_cc_Scene_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Scene) + +static bool js_new_cc_Scene__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string *arg1 = 0 ; + ccstd::string temp1 ; + cc::Scene *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::Scene *)new cc::Scene((ccstd::string const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Scene__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Scene *result; + result = (cc::Scene *)new cc::Scene(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_Scene(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_cc_Scene__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 0) { + ret = js_new_cc_Scene__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Scene"); + return false; +} +SE_BIND_CTOR(js_new_cc_Scene, __jsb_cc_Scene_class, js_delete_cc_Scene) + +static bool js_delete_cc_Scene(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Scene) + +static bool js_cc_Scene_getRenderScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + cc::scene::RenderScene *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)((cc::Scene const *)arg1)->getRenderScene(); + + 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_Scene_getRenderScene) + +static bool js_cc_Scene_getSceneGlobals(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + cc::SceneGlobals *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(s); + if (nullptr == arg1) return true; + result = (cc::SceneGlobals *)((cc::Scene const *)arg1)->getSceneGlobals(); + + 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_Scene_getSceneGlobals) + +static bool js_cc_Scene_setSceneGlobals(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + cc::SceneGlobals *arg2 = (cc::SceneGlobals *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSceneGlobals(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Scene_setSceneGlobals) + +static bool js_cc_Scene__load(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->load(); + + + return true; +} +SE_BIND_FUNC(js_cc_Scene__load) + +static bool js_cc_Scene__activate__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} + +static bool js_cc_Scene__activate__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} + +static bool js_cc_Scene__activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Scene__activate__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Scene__activate__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Scene__activate) + +static bool js_cc_Scene_onBatchCreated(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->onBatchCreated(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Scene_onBatchCreated) + +static bool js_cc_Scene_autoReleaseAssets_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Scene_autoReleaseAssets_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Scene_autoReleaseAssets_set) + +static bool js_cc_Scene_autoReleaseAssets_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Scene *arg1 = (cc::Scene *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Scene_autoReleaseAssets_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Scene_autoReleaseAssets_get) + +bool js_register_cc_Scene(se::Object* obj) { + auto* cls = se::Class::create("Scene", obj, __jsb_cc_Node_proto, _SE(js_new_cc_Scene)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("autoReleaseAssets", _SE(js_cc_Scene_autoReleaseAssets_get), _SE(js_cc_Scene_autoReleaseAssets_set)); + + cls->defineFunction("getRenderScene", _SE(js_cc_Scene_getRenderScene)); + cls->defineFunction("getSceneGlobals", _SE(js_cc_Scene_getSceneGlobals)); + cls->defineFunction("setSceneGlobals", _SE(js_cc_Scene_setSceneGlobals)); + cls->defineFunction("_load", _SE(js_cc_Scene__load)); + cls->defineFunction("_activate", _SE(js_cc_Scene__activate)); + cls->defineFunction("onBatchCreated", _SE(js_cc_Scene_onBatchCreated)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Scene)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Scene_proto = cls->getProto(); + __jsb_cc_Scene_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SceneGlobals_class = nullptr; +se::Object* __jsb_cc_SceneGlobals_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SceneGlobals) + +static bool js_new_cc_SceneGlobals(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SceneGlobals *result; + result = (cc::SceneGlobals *)new cc::SceneGlobals(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SceneGlobals, __jsb_cc_SceneGlobals_class, js_delete_cc_SceneGlobals) + +static bool js_delete_cc_SceneGlobals(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SceneGlobals) + +static bool js_cc_SceneGlobals_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::Scene *arg2 = (cc::Scene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_activate) + +static bool js_cc_SceneGlobals_getAmbientInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::AmbientInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::AmbientInfo *)((cc::SceneGlobals const *)arg1)->getAmbientInfo(); + + 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_SceneGlobals_getAmbientInfo) + +static bool js_cc_SceneGlobals_getShadowsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::ShadowsInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::ShadowsInfo *)((cc::SceneGlobals const *)arg1)->getShadowsInfo(); + + 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_SceneGlobals_getShadowsInfo) + +static bool js_cc_SceneGlobals_getSkyboxInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkyboxInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::SkyboxInfo *)((cc::SceneGlobals const *)arg1)->getSkyboxInfo(); + + 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_SceneGlobals_getSkyboxInfo) + +static bool js_cc_SceneGlobals_getFogInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::FogInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::FogInfo *)((cc::SceneGlobals const *)arg1)->getFogInfo(); + + 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_SceneGlobals_getFogInfo) + +static bool js_cc_SceneGlobals_getOctreeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::OctreeInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::OctreeInfo *)((cc::SceneGlobals const *)arg1)->getOctreeInfo(); + + 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_SceneGlobals_getOctreeInfo) + +static bool js_cc_SceneGlobals_getLightProbeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::gi::LightProbeInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::gi::LightProbeInfo *)((cc::SceneGlobals const *)arg1)->getLightProbeInfo(); + + 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_SceneGlobals_getLightProbeInfo) + +static bool js_cc_SceneGlobals_getSkinInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkinInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::SkinInfo *)((cc::SceneGlobals const *)arg1)->getSkinInfo(); + + 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_SceneGlobals_getSkinInfo) + +static bool js_cc_SceneGlobals_getPostSettingsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::PostSettingsInfo *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::PostSettingsInfo *)((cc::SceneGlobals const *)arg1)->getPostSettingsInfo(); + + 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_SceneGlobals_getPostSettingsInfo) + +static bool js_cc_SceneGlobals_setAmbientInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::AmbientInfo *arg2 = (cc::scene::AmbientInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAmbientInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setAmbientInfo) + +static bool js_cc_SceneGlobals_setShadowsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::ShadowsInfo *arg2 = (cc::scene::ShadowsInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowsInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setShadowsInfo) + +static bool js_cc_SceneGlobals_setSkyboxInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkyboxInfo *arg2 = (cc::scene::SkyboxInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSkyboxInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setSkyboxInfo) + +static bool js_cc_SceneGlobals_setFogInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::FogInfo *arg2 = (cc::scene::FogInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFogInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setFogInfo) + +static bool js_cc_SceneGlobals_setOctreeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::OctreeInfo *arg2 = (cc::scene::OctreeInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOctreeInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setOctreeInfo) + +static bool js_cc_SceneGlobals_setLightProbeInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::gi::LightProbeInfo *arg2 = (cc::gi::LightProbeInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLightProbeInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setLightProbeInfo) + +static bool js_cc_SceneGlobals_setSkinInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::SkinInfo *arg2 = (cc::scene::SkinInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSkinInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setSkinInfo) + +static bool js_cc_SceneGlobals_setPostSettingsInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + cc::scene::PostSettingsInfo *arg2 = (cc::scene::PostSettingsInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPostSettingsInfo(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SceneGlobals_setPostSettingsInfo) + +static bool js_cc_SceneGlobals_bakedWithStationaryMainLight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_SceneGlobals_bakedWithStationaryMainLight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_SceneGlobals_bakedWithStationaryMainLight_set) + +static bool js_cc_SceneGlobals_bakedWithStationaryMainLight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_SceneGlobals_bakedWithStationaryMainLight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_SceneGlobals_bakedWithStationaryMainLight_get) + +static bool js_cc_SceneGlobals_bakedWithHighpLightmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_SceneGlobals_bakedWithHighpLightmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_SceneGlobals_bakedWithHighpLightmap_set) + +static bool js_cc_SceneGlobals_bakedWithHighpLightmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::SceneGlobals *arg1 = (cc::SceneGlobals *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_SceneGlobals_bakedWithHighpLightmap_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_SceneGlobals_bakedWithHighpLightmap_get) + +bool js_register_cc_SceneGlobals(se::Object* obj) { + auto* cls = se::Class::create("SceneGlobals", obj, nullptr, _SE(js_new_cc_SceneGlobals)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bakedWithStationaryMainLight", _SE(js_cc_SceneGlobals_bakedWithStationaryMainLight_get), _SE(js_cc_SceneGlobals_bakedWithStationaryMainLight_set)); + cls->defineProperty("bakedWithHighpLightmap", _SE(js_cc_SceneGlobals_bakedWithHighpLightmap_get), _SE(js_cc_SceneGlobals_bakedWithHighpLightmap_set)); + + cls->defineFunction("activate", _SE(js_cc_SceneGlobals_activate)); + cls->defineFunction("getAmbientInfo", _SE(js_cc_SceneGlobals_getAmbientInfo)); + cls->defineFunction("getShadowsInfo", _SE(js_cc_SceneGlobals_getShadowsInfo)); + cls->defineFunction("getSkyboxInfo", _SE(js_cc_SceneGlobals_getSkyboxInfo)); + cls->defineFunction("getFogInfo", _SE(js_cc_SceneGlobals_getFogInfo)); + cls->defineFunction("getOctreeInfo", _SE(js_cc_SceneGlobals_getOctreeInfo)); + cls->defineFunction("getLightProbeInfo", _SE(js_cc_SceneGlobals_getLightProbeInfo)); + cls->defineFunction("getSkinInfo", _SE(js_cc_SceneGlobals_getSkinInfo)); + cls->defineFunction("getPostSettingsInfo", _SE(js_cc_SceneGlobals_getPostSettingsInfo)); + cls->defineFunction("setAmbientInfo", _SE(js_cc_SceneGlobals_setAmbientInfo)); + cls->defineFunction("setShadowsInfo", _SE(js_cc_SceneGlobals_setShadowsInfo)); + cls->defineFunction("setSkyboxInfo", _SE(js_cc_SceneGlobals_setSkyboxInfo)); + cls->defineFunction("setFogInfo", _SE(js_cc_SceneGlobals_setFogInfo)); + cls->defineFunction("setOctreeInfo", _SE(js_cc_SceneGlobals_setOctreeInfo)); + cls->defineFunction("setLightProbeInfo", _SE(js_cc_SceneGlobals_setLightProbeInfo)); + cls->defineFunction("setSkinInfo", _SE(js_cc_SceneGlobals_setSkinInfo)); + cls->defineFunction("setPostSettingsInfo", _SE(js_cc_SceneGlobals_setPostSettingsInfo)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SceneGlobals)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SceneGlobals_proto = cls->getProto(); + __jsb_cc_SceneGlobals_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_Root_class = nullptr; +se::Object* __jsb_cc_Root_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_Root) + +static bool js_cc_Root_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::Root *)cc::Root::getInstance(); + + 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_Root_getInstance_static) + +static bool js_new_cc_Root(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::Root *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::Root *)new cc::Root(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_Root, __jsb_cc_Root_class, js_delete_cc_Root) + +static bool js_delete_cc_Root(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_Root) + +static bool js_cc_Root__initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Swapchain *arg2 = (cc::gfx::Swapchain *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root__initialize) + +static bool js_cc_Root_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroy) + +static bool js_cc_Root_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + uint32_t arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_resize) + +static bool js_cc_Root_setRenderPipeline__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::pipeline::RenderPipeline *arg2 = (cc::pipeline::RenderPipeline *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(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)->setRenderPipeline(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Root_setRenderPipeline__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->setRenderPipeline(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_Root_setRenderPipeline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Root_setRenderPipeline__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_Root_setRenderPipeline__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Root_setRenderPipeline) + +static bool js_cc_Root_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_onGlobalPipelineStateChanged) + +static bool js_cc_Root_activeWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activeWindow(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_activeWindow) + +static bool js_cc_Root_resetCumulativeTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetCumulativeTime(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_resetCumulativeTime) + +static bool js_cc_Root_frameMove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + float arg2 ; + int32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->frameMove(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_frameMove) + +static bool js_cc_Root_createWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::IRenderWindowInfo *arg2 = 0 ; + cc::scene::IRenderWindowInfo temp2 ; + cc::scene::RenderWindow *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(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::scene::RenderWindow *)(arg1)->createWindow(*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_Root_createWindow) + +static bool js_cc_Root_destroyWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyWindow(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyWindow) + +static bool js_cc_Root_destroyWindows(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyWindows(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyWindows) + +static bool js_cc_Root_createSystemWindow_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ISystemWindowInfo *arg1 = 0 ; + cc::ISystemWindowInfo temp1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = cc::Root::createSystemWindow((cc::ISystemWindowInfo const &)*arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_createSystemWindow_static) + +static bool js_cc_Root_createScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::IRenderSceneInfo *arg2 = 0 ; + cc::scene::IRenderSceneInfo temp2 ; + cc::scene::RenderScene *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(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::scene::RenderScene *)(arg1)->createScene((cc::scene::IRenderSceneInfo 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_Root_createScene) + +static bool js_cc_Root_destroyScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyScene) + +static bool js_cc_Root_destroyScenes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroyScenes(); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyScenes) + +static bool js_cc_Root_destroyModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyModel) + +static bool js_cc_Root_destroyLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Light *arg2 = (cc::scene::Light *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->destroyLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_Root_destroyLight) + +static bool js_cc_Root_createCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Camera *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Camera *)((cc::Root const *)arg1)->createCamera(); + + 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_Root_createCamera) + +static bool js_cc_Root_getBatcher2D(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::Batcher2d *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(s); + if (nullptr == arg1) return true; + result = (cc::Batcher2d *)((cc::Root const *)arg1)->getBatcher2D(); + + 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_Root_getBatcher2D) + +static bool js_cc_Root_createRenderWindowFromSystemWindow__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t arg2 ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::scene::RenderWindow *)(arg1)->createRenderWindowFromSystemWindow(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_Root_createRenderWindowFromSystemWindow__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::ISystemWindow *arg2 = (cc::ISystemWindow *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::RenderWindow *)(arg1)->createRenderWindowFromSystemWindow(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_Root_createRenderWindowFromSystemWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_Root_createRenderWindowFromSystemWindow__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_Root_createRenderWindowFromSystemWindow__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_Root_createRenderWindowFromSystemWindow) + +static bool js_cc_Root_device_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root_device_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_device_set) + +static bool js_cc_Root_device_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)cc_Root_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_Root_device_get) + +static bool js_cc_Root__device_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root__device_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root__device_set) + +static bool js_cc_Root__device_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::gfx::Device *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)cc_Root__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_Root__device_get) + +static bool js_cc_Root_mainWindow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_Root_mainWindow_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_Root_mainWindow_get) + +static bool js_cc_Root_curWindow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root_curWindow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_curWindow_set) + +static bool js_cc_Root_curWindow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_Root_curWindow_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_Root_curWindow_get) + +static bool js_cc_Root_tempWindow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_Root_tempWindow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_tempWindow_set) + +static bool js_cc_Root_tempWindow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_Root_tempWindow_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_Root_tempWindow_get) + +static bool js_cc_Root_windows_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::RenderWindow > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::RenderWindow > > *) &cc_Root_windows_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_Root_windows_get) + +static bool js_cc_Root_scenes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::RenderScene > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::RenderScene > > *) &cc_Root_scenes_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_Root_scenes_get) + +static bool js_cc_Root_cumulativeTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_Root_cumulativeTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_cumulativeTime_get) + +static bool js_cc_Root_frameTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_Root_frameTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_frameTime_get) + +static bool js_cc_Root_frameCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Root_frameCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_frameCount_get) + +static bool js_cc_Root_fps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Root_fps_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_fps_get) + +static bool js_cc_Root_fixedFPS_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_Root_fixedFPS_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_Root_fixedFPS_set) + +static bool js_cc_Root_fixedFPS_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_Root_fixedFPS_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_fixedFPS_get) + +static bool js_cc_Root_useDeferredPipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Root_useDeferredPipeline_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_useDeferredPipeline_get) + +static bool js_cc_Root_usesCustomPipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_Root_usesCustomPipeline_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_Root_usesCustomPipeline_get) + +static bool js_cc_Root_pipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::render::PipelineRuntime *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::PipelineRuntime *)cc_Root_pipeline_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_Root_pipeline_get) + +static bool js_cc_Root_customPipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::render::Pipeline *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::render::Pipeline *)cc_Root_customPipeline_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_Root_customPipeline_get) + +static bool js_cc_Root_cameraList_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + ccstd::vector< cc::scene::Camera * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::scene::Camera * > *) &cc_Root_cameraList_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_Root_cameraList_get) + +static bool js_cc_Root_debugView_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::pipeline::DebugView *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::DebugView *)cc_Root_debugView_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_Root_debugView_get) + +bool js_register_cc_Root(se::Object* obj) { + auto* cls = se::Class::create("Root", obj, nullptr, _SE(js_new_cc_Root)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("device", _SE(js_cc_Root_device_get), _SE(js_cc_Root_device_set)); + cls->defineProperty("_device", _SE(js_cc_Root__device_get), _SE(js_cc_Root__device_set)); + cls->defineProperty("mainWindow", _SE(js_cc_Root_mainWindow_get), nullptr); + cls->defineProperty("curWindow", _SE(js_cc_Root_curWindow_get), _SE(js_cc_Root_curWindow_set)); + cls->defineProperty("tempWindow", _SE(js_cc_Root_tempWindow_get), _SE(js_cc_Root_tempWindow_set)); + cls->defineProperty("windows", _SE(js_cc_Root_windows_get), nullptr); + cls->defineProperty("scenes", _SE(js_cc_Root_scenes_get), nullptr); + cls->defineProperty("cumulativeTime", _SE(js_cc_Root_cumulativeTime_get), nullptr); + cls->defineProperty("frameTime", _SE(js_cc_Root_frameTime_get), nullptr); + cls->defineProperty("frameCount", _SE(js_cc_Root_frameCount_get), nullptr); + cls->defineProperty("fps", _SE(js_cc_Root_fps_get), nullptr); + cls->defineProperty("fixedFPS", _SE(js_cc_Root_fixedFPS_get), _SE(js_cc_Root_fixedFPS_set)); + cls->defineProperty("useDeferredPipeline", _SE(js_cc_Root_useDeferredPipeline_get), nullptr); + cls->defineProperty("usesCustomPipeline", _SE(js_cc_Root_usesCustomPipeline_get), nullptr); + cls->defineProperty("pipeline", _SE(js_cc_Root_pipeline_get), nullptr); + cls->defineProperty("customPipeline", _SE(js_cc_Root_customPipeline_get), nullptr); + cls->defineProperty("cameraList", _SE(js_cc_Root_cameraList_get), nullptr); + cls->defineProperty("debugView", _SE(js_cc_Root_debugView_get), nullptr); + + cls->defineFunction("_initialize", _SE(js_cc_Root__initialize)); + cls->defineFunction("destroy", _SE(js_cc_Root_destroy)); + cls->defineFunction("resize", _SE(js_cc_Root_resize)); + cls->defineFunction("setRenderPipeline", _SE(js_cc_Root_setRenderPipeline)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_Root_onGlobalPipelineStateChanged)); + cls->defineFunction("activeWindow", _SE(js_cc_Root_activeWindow)); + cls->defineFunction("resetCumulativeTime", _SE(js_cc_Root_resetCumulativeTime)); + cls->defineFunction("frameMove", _SE(js_cc_Root_frameMove)); + cls->defineFunction("createWindow", _SE(js_cc_Root_createWindow)); + cls->defineFunction("destroyWindow", _SE(js_cc_Root_destroyWindow)); + cls->defineFunction("destroyWindows", _SE(js_cc_Root_destroyWindows)); + cls->defineFunction("createScene", _SE(js_cc_Root_createScene)); + cls->defineFunction("destroyScene", _SE(js_cc_Root_destroyScene)); + cls->defineFunction("destroyScenes", _SE(js_cc_Root_destroyScenes)); + cls->defineFunction("destroyModel", _SE(js_cc_Root_destroyModel)); + cls->defineFunction("destroyLight", _SE(js_cc_Root_destroyLight)); + cls->defineFunction("createCamera", _SE(js_cc_Root_createCamera)); + cls->defineFunction("getBatcher2D", _SE(js_cc_Root_getBatcher2D)); + cls->defineFunction("createRenderWindowFromSystemWindow", _SE(js_cc_Root_createRenderWindowFromSystemWindow)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_Root_getInstance_static)); + cls->defineStaticFunction("createSystemWindow", _SE(js_cc_Root_createSystemWindow_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_Root)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_Root_proto = cls->getProto(); + __jsb_cc_Root_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IMacroPatch_class = nullptr; +se::Object* __jsb_cc_scene_IMacroPatch_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IMacroPatch) + +static bool js_cc_scene_IMacroPatch_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IMacroPatch_name_set) + +static bool js_cc_scene_IMacroPatch_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IMacroPatch_name_get) + +static bool js_cc_scene_IMacroPatch_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IMacroPatch_value_set) + +static bool js_cc_scene_IMacroPatch_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IMacroPatch *arg1 = (cc::scene::IMacroPatch *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->value, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IMacroPatch_value_get) + +static bool js_new_cc_scene_IMacroPatch__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::scene::IMacroPatch *result; + result = (cc::scene::IMacroPatch *)new cc::scene::IMacroPatch(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_IMacroPatch__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + ccstd::string *arg1 = 0 ; + cc::MacroValue *arg2 = 0 ; + ccstd::string temp1 ; + cc::MacroValue temp2 ; + cc::scene::IMacroPatch *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::scene::IMacroPatch *)new cc::scene::IMacroPatch((ccstd::string const &)*arg1,(cc::MacroValue const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_IMacroPatch(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_scene_IMacroPatch__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_scene_IMacroPatch__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of IMacroPatch"); + return false; +} +SE_BIND_CTOR(js_new_cc_scene_IMacroPatch, __jsb_cc_scene_IMacroPatch_class, js_delete_cc_scene_IMacroPatch) + +static bool js_cc_scene_IMacroPatch_compare_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IMacroPatch *arg1 = 0 ; + cc::scene::IMacroPatch *arg2 = 0 ; + cc::scene::IMacroPatch temp1 ; + cc::scene::IMacroPatch temp2 ; + bool result; + + 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], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (bool)cc::scene::IMacroPatch::compare((cc::scene::IMacroPatch const &)*arg1,(cc::scene::IMacroPatch const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_IMacroPatch_compare_static) + +static bool js_delete_cc_scene_IMacroPatch(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IMacroPatch) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IMacroPatch * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IMacroPatch(se::Object* obj) { + auto* cls = se::Class::create("IMacroPatch", obj, nullptr, _SE(js_new_cc_scene_IMacroPatch)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_IMacroPatch_name_get), _SE(js_cc_scene_IMacroPatch_name_set)); + cls->defineProperty("value", _SE(js_cc_scene_IMacroPatch_value_get), _SE(js_cc_scene_IMacroPatch_value_set)); + + + + cls->defineStaticFunction("compare", _SE(js_cc_scene_IMacroPatch_compare_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IMacroPatch)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IMacroPatch_proto = cls->getProto(); + __jsb_cc_scene_IMacroPatch_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Light_class = nullptr; +se::Object* __jsb_cc_scene_Light_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Light) + +static bool js_new_cc_scene_Light(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Light *result; + result = (cc::scene::Light *)new cc::scene::Light(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Light, __jsb_cc_scene_Light_class, js_delete_cc_scene_Light) + +static bool js_delete_cc_scene_Light(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Light) + +static bool js_cc_scene_Light_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_attachToScene) + +static bool js_cc_scene_Light_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_detachFromScene) + +static bool js_cc_scene_Light_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_destroy) + +static bool js_cc_scene_Light_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_initialize) + +static bool js_cc_scene_Light_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_update) + +static bool js_cc_scene_Light_nt2lm_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)cc::scene::Light::nt2lm(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_nt2lm_static) + +static bool js_cc_scene_Light_colorTemperatureToRGB_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::scene::Light::colorTemperatureToRGB(arg1); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Light_colorTemperatureToRGB_static) + +static bool js_cc_scene_Light_baked_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_baked_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_baked_set) + +static bool js_cc_scene_Light_baked_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Light_baked_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_baked_get) + +static bool js_cc_scene_Light_color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Light_color_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_color_set) + +static bool js_cc_scene_Light_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Light_color_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_scene_Light_color_get) + +static bool js_cc_scene_Light_useColorTemperature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_useColorTemperature_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_useColorTemperature_set) + +static bool js_cc_scene_Light_useColorTemperature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Light_useColorTemperature_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_useColorTemperature_get) + +static bool js_cc_scene_Light_colorTemperature_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_colorTemperature_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_colorTemperature_set) + +static bool js_cc_scene_Light_colorTemperature_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Light_colorTemperature_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_colorTemperature_get) + +static bool js_cc_scene_Light_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Light_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_node_set) + +static bool js_cc_scene_Light_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Light_node_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_scene_Light_node_get) + +static bool js_cc_scene_Light_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::LightType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Light_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_type_set) + +static bool js_cc_scene_Light_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::LightType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::LightType)cc_scene_Light_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_type_get) + +static bool js_cc_scene_Light_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Light_name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_name_set) + +static bool js_cc_scene_Light_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_Light_name_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_scene_Light_name_get) + +static bool js_cc_scene_Light_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_Light_scene_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_scene_Light_scene_get) + +static bool js_cc_scene_Light_visibility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Light_visibility_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_visibility_set) + +static bool js_cc_scene_Light_visibility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Light_visibility_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Light_visibility_get) + +static bool js_cc_scene_Light_colorTemperatureRGB_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Light_colorTemperatureRGB_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Light_colorTemperatureRGB_set) + +static bool js_cc_scene_Light_colorTemperatureRGB_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Light *arg1 = (cc::scene::Light *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Light_colorTemperatureRGB_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_scene_Light_colorTemperatureRGB_get) + +bool js_register_cc_scene_Light(se::Object* obj) { + auto* cls = se::Class::create("Light", obj, nullptr, _SE(js_new_cc_scene_Light)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("baked", _SE(js_cc_scene_Light_baked_get), _SE(js_cc_scene_Light_baked_set)); + cls->defineProperty("color", _SE(js_cc_scene_Light_color_get), _SE(js_cc_scene_Light_color_set)); + cls->defineProperty("useColorTemperature", _SE(js_cc_scene_Light_useColorTemperature_get), _SE(js_cc_scene_Light_useColorTemperature_set)); + cls->defineProperty("colorTemperature", _SE(js_cc_scene_Light_colorTemperature_get), _SE(js_cc_scene_Light_colorTemperature_set)); + cls->defineProperty("node", _SE(js_cc_scene_Light_node_get), _SE(js_cc_scene_Light_node_set)); + cls->defineProperty("type", _SE(js_cc_scene_Light_type_get), _SE(js_cc_scene_Light_type_set)); + cls->defineProperty("name", _SE(js_cc_scene_Light_name_get), _SE(js_cc_scene_Light_name_set)); + cls->defineProperty("scene", _SE(js_cc_scene_Light_scene_get), nullptr); + cls->defineProperty("visibility", _SE(js_cc_scene_Light_visibility_get), _SE(js_cc_scene_Light_visibility_set)); + cls->defineProperty("colorTemperatureRGB", _SE(js_cc_scene_Light_colorTemperatureRGB_get), _SE(js_cc_scene_Light_colorTemperatureRGB_set)); + + cls->defineFunction("attachToScene", _SE(js_cc_scene_Light_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_Light_detachFromScene)); + cls->defineFunction("destroy", _SE(js_cc_scene_Light_destroy)); + cls->defineFunction("initialize", _SE(js_cc_scene_Light_initialize)); + cls->defineFunction("update", _SE(js_cc_scene_Light_update)); + + + cls->defineStaticFunction("nt2lm", _SE(js_cc_scene_Light_nt2lm_static)); + cls->defineStaticFunction("colorTemperatureToRGB", _SE(js_cc_scene_Light_colorTemperatureToRGB_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Light)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Light_proto = cls->getProto(); + __jsb_cc_scene_Light_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_LODData_class = nullptr; +se::Object* __jsb_cc_scene_LODData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_LODData) + +static bool js_cc_scene_LODData_addModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODData_addModel) + +static bool js_cc_scene_LODData_clearModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODData_clearModels) + +static bool js_cc_scene_LODData_eraseModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->eraseModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODData_eraseModel) + +static bool js_cc_scene_LODData_screenUsagePercentage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODData_screenUsagePercentage_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODData_screenUsagePercentage_set) + +static bool js_cc_scene_LODData_screenUsagePercentage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_LODData_screenUsagePercentage_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODData_screenUsagePercentage_get) + +static bool js_cc_scene_LODData_models_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODData *arg1 = (cc::scene::LODData *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *) &cc_scene_LODData_models_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_scene_LODData_models_get) + +static bool js_new_cc_scene_LODData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::LODData *result; + result = (cc::scene::LODData *)new cc::scene::LODData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_LODData, __jsb_cc_scene_LODData_class, js_delete_cc_scene_LODData) + +static bool js_delete_cc_scene_LODData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_LODData) + +bool js_register_cc_scene_LODData(se::Object* obj) { + auto* cls = se::Class::create("LODData", obj, nullptr, _SE(js_new_cc_scene_LODData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("screenUsagePercentage", _SE(js_cc_scene_LODData_screenUsagePercentage_get), _SE(js_cc_scene_LODData_screenUsagePercentage_set)); + cls->defineProperty("models", _SE(js_cc_scene_LODData_models_get), nullptr); + + cls->defineFunction("addModel", _SE(js_cc_scene_LODData_addModel)); + cls->defineFunction("clearModels", _SE(js_cc_scene_LODData_clearModels)); + cls->defineFunction("eraseModel", _SE(js_cc_scene_LODData_eraseModel)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_LODData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_LODData_proto = cls->getProto(); + __jsb_cc_scene_LODData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_LODGroup_class = nullptr; +se::Object* __jsb_cc_scene_LODGroup_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_LODGroup) + +static bool js_new_cc_scene_LODGroup(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::LODGroup *result; + result = (cc::scene::LODGroup *)new cc::scene::LODGroup(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_LODGroup, __jsb_cc_scene_LODGroup_class, js_delete_cc_scene_LODGroup) + +static bool js_delete_cc_scene_LODGroup(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_LODGroup) + +static bool js_cc_scene_LODGroup_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_attachToScene) + +static bool js_cc_scene_LODGroup_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_detachFromScene) + +static bool js_cc_scene_LODGroup_getVisibleLODLevel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + int8_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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = ((cc::scene::LODGroup const *)arg1)->getVisibleLODLevel((cc::scene::Camera const *)arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_getVisibleLODLevel) + +static bool js_cc_scene_LODGroup_getLockedLODLevels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + ccstd::vector< uint8_t > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< uint8_t > *) &((cc::scene::LODGroup const *)arg1)->getLockedLODLevels(); + + 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_scene_LODGroup_getLockedLODLevels) + +static bool js_cc_scene_LODGroup_lockLODLevels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + ccstd::vector< int > *arg2 = 0 ; + ccstd::vector< int > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->lockLODLevels(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_lockLODLevels) + +static bool js_cc_scene_LODGroup_isLockLevelChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::LODGroup const *)arg1)->isLockLevelChanged(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_isLockLevelChanged) + +static bool js_cc_scene_LODGroup_resetLockChangeFlag(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetLockChangeFlag(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_resetLockChangeFlag) + +static bool js_cc_scene_LODGroup_clearLODs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearLODs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_clearLODs) + +static bool js_cc_scene_LODGroup_insertLOD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t arg2 ; + cc::scene::LODData *arg3 = (cc::scene::LODData *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->insertLOD(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_insertLOD) + +static bool js_cc_scene_LODGroup_updateLOD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t arg2 ; + cc::scene::LODData *arg3 = (cc::scene::LODData *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLOD(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_updateLOD) + +static bool js_cc_scene_LODGroup_eraseLOD(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->eraseLOD(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_LODGroup_eraseLOD) + +static bool js_cc_scene_LODGroup_lodCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + uint8_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_LODGroup_lodCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODGroup_lodCount_get) + +static bool js_cc_scene_LODGroup_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODGroup_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_enabled_set) + +static bool js_cc_scene_LODGroup_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_LODGroup_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODGroup_enabled_get) + +static bool js_cc_scene_LODGroup_localBoundaryCenter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_LODGroup_localBoundaryCenter_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_localBoundaryCenter_set) + +static bool js_cc_scene_LODGroup_localBoundaryCenter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_LODGroup_localBoundaryCenter_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_scene_LODGroup_localBoundaryCenter_get) + +static bool js_cc_scene_LODGroup_objectSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODGroup_objectSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_objectSize_set) + +static bool js_cc_scene_LODGroup_objectSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_LODGroup_objectSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_LODGroup_objectSize_get) + +static bool js_cc_scene_LODGroup_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_LODGroup_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_LODGroup_node_set) + +static bool js_cc_scene_LODGroup_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_LODGroup_node_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_scene_LODGroup_node_get) + +static bool js_cc_scene_LODGroup_lodDataArray_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::LODData > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::LODData > > *) &cc_scene_LODGroup_lodDataArray_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_scene_LODGroup_lodDataArray_get) + +static bool js_cc_scene_LODGroup_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::LODGroup *arg1 = (cc::scene::LODGroup *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_LODGroup_scene_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_scene_LODGroup_scene_get) + +bool js_register_cc_scene_LODGroup(se::Object* obj) { + auto* cls = se::Class::create("LODGroup", obj, nullptr, _SE(js_new_cc_scene_LODGroup)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("lodCount", _SE(js_cc_scene_LODGroup_lodCount_get), nullptr); + cls->defineProperty("enabled", _SE(js_cc_scene_LODGroup_enabled_get), _SE(js_cc_scene_LODGroup_enabled_set)); + cls->defineProperty("localBoundaryCenter", _SE(js_cc_scene_LODGroup_localBoundaryCenter_get), _SE(js_cc_scene_LODGroup_localBoundaryCenter_set)); + cls->defineProperty("objectSize", _SE(js_cc_scene_LODGroup_objectSize_get), _SE(js_cc_scene_LODGroup_objectSize_set)); + cls->defineProperty("node", _SE(js_cc_scene_LODGroup_node_get), _SE(js_cc_scene_LODGroup_node_set)); + cls->defineProperty("lodDataArray", _SE(js_cc_scene_LODGroup_lodDataArray_get), nullptr); + cls->defineProperty("scene", _SE(js_cc_scene_LODGroup_scene_get), nullptr); + + cls->defineFunction("attachToScene", _SE(js_cc_scene_LODGroup_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_LODGroup_detachFromScene)); + cls->defineFunction("getVisibleLODLevel", _SE(js_cc_scene_LODGroup_getVisibleLODLevel)); + cls->defineFunction("getLockedLODLevels", _SE(js_cc_scene_LODGroup_getLockedLODLevels)); + cls->defineFunction("lockLODLevels", _SE(js_cc_scene_LODGroup_lockLODLevels)); + cls->defineFunction("isLockLevelChanged", _SE(js_cc_scene_LODGroup_isLockLevelChanged)); + cls->defineFunction("resetLockChangeFlag", _SE(js_cc_scene_LODGroup_resetLockChangeFlag)); + cls->defineFunction("clearLODs", _SE(js_cc_scene_LODGroup_clearLODs)); + cls->defineFunction("insertLOD", _SE(js_cc_scene_LODGroup_insertLOD)); + cls->defineFunction("updateLOD", _SE(js_cc_scene_LODGroup_updateLOD)); + cls->defineFunction("eraseLOD", _SE(js_cc_scene_LODGroup_eraseLOD)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_LODGroup)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_LODGroup_proto = cls->getProto(); + __jsb_cc_scene_LODGroup_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Fog_class = nullptr; +se::Object* __jsb_cc_scene_Fog_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Fog) + +static bool js_new_cc_scene_Fog(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Fog *result; + result = (cc::scene::Fog *)new cc::scene::Fog(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Fog, __jsb_cc_scene_Fog_class, js_delete_cc_scene_Fog) + +static bool js_delete_cc_scene_Fog(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Fog) + +static bool js_cc_scene_Fog_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::scene::FogInfo *arg2 = 0 ; + cc::scene::FogInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::FogInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Fog_initialize) + +static bool js_cc_scene_Fog_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Fog_activate) + +static bool js_cc_scene_Fog_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_enabled_set) + +static bool js_cc_scene_Fog_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Fog_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_enabled_get) + +static bool js_cc_scene_Fog_accurate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_accurate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_accurate_set) + +static bool js_cc_scene_Fog_accurate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Fog_accurate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_accurate_get) + +static bool js_cc_scene_Fog_fogColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Fog_fogColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogColor_set) + +static bool js_cc_scene_Fog_fogColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_Fog_fogColor_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_scene_Fog_fogColor_get) + +static bool js_cc_scene_Fog_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::scene::FogType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Fog_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_type_set) + +static bool js_cc_scene_Fog_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::scene::FogType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::FogType)cc_scene_Fog_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_type_get) + +static bool js_cc_scene_Fog_fogDensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogDensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogDensity_set) + +static bool js_cc_scene_Fog_fogDensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogDensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogDensity_get) + +static bool js_cc_scene_Fog_fogStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogStart_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogStart_set) + +static bool js_cc_scene_Fog_fogStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogStart_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogStart_get) + +static bool js_cc_scene_Fog_fogEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogEnd_set) + +static bool js_cc_scene_Fog_fogEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogEnd_get) + +static bool js_cc_scene_Fog_fogAtten_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogAtten_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogAtten_set) + +static bool js_cc_scene_Fog_fogAtten_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogAtten_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogAtten_get) + +static bool js_cc_scene_Fog_fogTop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogTop_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogTop_set) + +static bool js_cc_scene_Fog_fogTop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogTop_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogTop_get) + +static bool js_cc_scene_Fog_fogRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Fog_fogRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Fog_fogRange_set) + +static bool js_cc_scene_Fog_fogRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Fog_fogRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Fog_fogRange_get) + +static bool js_cc_scene_Fog_colorArray_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Fog *arg1 = (cc::scene::Fog *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_Fog_colorArray_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_scene_Fog_colorArray_get) + +bool js_register_cc_scene_Fog(se::Object* obj) { + auto* cls = se::Class::create("Fog", obj, nullptr, _SE(js_new_cc_scene_Fog)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enabled", _SE(js_cc_scene_Fog_enabled_get), _SE(js_cc_scene_Fog_enabled_set)); + cls->defineProperty("accurate", _SE(js_cc_scene_Fog_accurate_get), _SE(js_cc_scene_Fog_accurate_set)); + cls->defineProperty("fogColor", _SE(js_cc_scene_Fog_fogColor_get), _SE(js_cc_scene_Fog_fogColor_set)); + cls->defineProperty("type", _SE(js_cc_scene_Fog_type_get), _SE(js_cc_scene_Fog_type_set)); + cls->defineProperty("fogDensity", _SE(js_cc_scene_Fog_fogDensity_get), _SE(js_cc_scene_Fog_fogDensity_set)); + cls->defineProperty("fogStart", _SE(js_cc_scene_Fog_fogStart_get), _SE(js_cc_scene_Fog_fogStart_set)); + cls->defineProperty("fogEnd", _SE(js_cc_scene_Fog_fogEnd_get), _SE(js_cc_scene_Fog_fogEnd_set)); + cls->defineProperty("fogAtten", _SE(js_cc_scene_Fog_fogAtten_get), _SE(js_cc_scene_Fog_fogAtten_set)); + cls->defineProperty("fogTop", _SE(js_cc_scene_Fog_fogTop_get), _SE(js_cc_scene_Fog_fogTop_set)); + cls->defineProperty("fogRange", _SE(js_cc_scene_Fog_fogRange_get), _SE(js_cc_scene_Fog_fogRange_set)); + cls->defineProperty("colorArray", _SE(js_cc_scene_Fog_colorArray_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Fog_initialize)); + cls->defineFunction("activate", _SE(js_cc_scene_Fog_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Fog)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Fog_proto = cls->getProto(); + __jsb_cc_scene_Fog_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_FogInfo_class = nullptr; +se::Object* __jsb_cc_scene_FogInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_FogInfo) + +static bool js_new_cc_scene_FogInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::FogInfo *result; + result = (cc::scene::FogInfo *)new cc::scene::FogInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_FogInfo, __jsb_cc_scene_FogInfo_class, js_delete_cc_scene_FogInfo) + +static bool js_delete_cc_scene_FogInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_FogInfo) + +static bool js_cc_scene_FogInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::scene::Fog *arg2 = (cc::scene::Fog *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_FogInfo_activate) + +static bool js_cc_scene_FogInfo__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__type_set) + +static bool js_cc_scene_FogInfo__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__type_get) + +static bool js_cc_scene_FogInfo__fogColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogColor_set) + +static bool js_cc_scene_FogInfo__fogColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_fogColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogColor_get) + +static bool js_cc_scene_FogInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_isEnabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__enabled_set) + +static bool js_cc_scene_FogInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_isEnabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__enabled_get) + +static bool js_cc_scene_FogInfo__fogDensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogDensity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogDensity_set) + +static bool js_cc_scene_FogInfo__fogDensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogDensity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogDensity_get) + +static bool js_cc_scene_FogInfo__fogStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogStart, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogStart_set) + +static bool js_cc_scene_FogInfo__fogStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogStart, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogStart_get) + +static bool js_cc_scene_FogInfo__fogEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogEnd, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogEnd_set) + +static bool js_cc_scene_FogInfo__fogEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogEnd, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogEnd_get) + +static bool js_cc_scene_FogInfo__fogAtten_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogAtten, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogAtten_set) + +static bool js_cc_scene_FogInfo__fogAtten_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogAtten, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogAtten_get) + +static bool js_cc_scene_FogInfo__fogTop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogTop, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogTop_set) + +static bool js_cc_scene_FogInfo__fogTop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogTop, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogTop_get) + +static bool js_cc_scene_FogInfo__fogRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_fogRange, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__fogRange_set) + +static bool js_cc_scene_FogInfo__fogRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_fogRange, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__fogRange_get) + +static bool js_cc_scene_FogInfo__accurate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_accurate); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__accurate_set) + +static bool js_cc_scene_FogInfo__accurate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_accurate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__accurate_get) + +static bool js_cc_scene_FogInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo__resource_set) + +static bool js_cc_scene_FogInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo__resource_get) + +static bool js_cc_scene_FogInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::scene::FogType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_FogInfo_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_type_set) + +static bool js_cc_scene_FogInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::scene::FogType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::FogType)cc_scene_FogInfo_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_type_get) + +static bool js_cc_scene_FogInfo_fogColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_FogInfo_fogColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogColor_set) + +static bool js_cc_scene_FogInfo_fogColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_FogInfo_fogColor_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_scene_FogInfo_fogColor_get) + +static bool js_cc_scene_FogInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_enabled_set) + +static bool js_cc_scene_FogInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_FogInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_enabled_get) + +static bool js_cc_scene_FogInfo_accurate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_accurate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_accurate_set) + +static bool js_cc_scene_FogInfo_accurate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_FogInfo_accurate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_accurate_get) + +static bool js_cc_scene_FogInfo_fogDensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogDensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogDensity_set) + +static bool js_cc_scene_FogInfo_fogDensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogDensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogDensity_get) + +static bool js_cc_scene_FogInfo_fogStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogStart_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogStart_set) + +static bool js_cc_scene_FogInfo_fogStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogStart_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogStart_get) + +static bool js_cc_scene_FogInfo_fogEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogEnd_set) + +static bool js_cc_scene_FogInfo_fogEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogEnd_get) + +static bool js_cc_scene_FogInfo_fogAtten_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogAtten_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogAtten_set) + +static bool js_cc_scene_FogInfo_fogAtten_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogAtten_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogAtten_get) + +static bool js_cc_scene_FogInfo_fogTop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogTop_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogTop_set) + +static bool js_cc_scene_FogInfo_fogTop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogTop_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogTop_get) + +static bool js_cc_scene_FogInfo_fogRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_FogInfo_fogRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_FogInfo_fogRange_set) + +static bool js_cc_scene_FogInfo_fogRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::FogInfo *arg1 = (cc::scene::FogInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_FogInfo_fogRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_FogInfo_fogRange_get) + +bool js_register_cc_scene_FogInfo(se::Object* obj) { + auto* cls = se::Class::create("FogInfo", obj, nullptr, _SE(js_new_cc_scene_FogInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_type", _SE(js_cc_scene_FogInfo__type_get), _SE(js_cc_scene_FogInfo__type_set)); + cls->defineProperty("_fogColor", _SE(js_cc_scene_FogInfo__fogColor_get), _SE(js_cc_scene_FogInfo__fogColor_set)); + cls->defineProperty("_enabled", _SE(js_cc_scene_FogInfo__enabled_get), _SE(js_cc_scene_FogInfo__enabled_set)); + cls->defineProperty("_fogDensity", _SE(js_cc_scene_FogInfo__fogDensity_get), _SE(js_cc_scene_FogInfo__fogDensity_set)); + cls->defineProperty("_fogStart", _SE(js_cc_scene_FogInfo__fogStart_get), _SE(js_cc_scene_FogInfo__fogStart_set)); + cls->defineProperty("_fogEnd", _SE(js_cc_scene_FogInfo__fogEnd_get), _SE(js_cc_scene_FogInfo__fogEnd_set)); + cls->defineProperty("_fogAtten", _SE(js_cc_scene_FogInfo__fogAtten_get), _SE(js_cc_scene_FogInfo__fogAtten_set)); + cls->defineProperty("_fogTop", _SE(js_cc_scene_FogInfo__fogTop_get), _SE(js_cc_scene_FogInfo__fogTop_set)); + cls->defineProperty("_fogRange", _SE(js_cc_scene_FogInfo__fogRange_get), _SE(js_cc_scene_FogInfo__fogRange_set)); + cls->defineProperty("_accurate", _SE(js_cc_scene_FogInfo__accurate_get), _SE(js_cc_scene_FogInfo__accurate_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_FogInfo__resource_get), _SE(js_cc_scene_FogInfo__resource_set)); + cls->defineProperty("type", _SE(js_cc_scene_FogInfo_type_get), _SE(js_cc_scene_FogInfo_type_set)); + cls->defineProperty("fogColor", _SE(js_cc_scene_FogInfo_fogColor_get), _SE(js_cc_scene_FogInfo_fogColor_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_FogInfo_enabled_get), _SE(js_cc_scene_FogInfo_enabled_set)); + cls->defineProperty("accurate", _SE(js_cc_scene_FogInfo_accurate_get), _SE(js_cc_scene_FogInfo_accurate_set)); + cls->defineProperty("fogDensity", _SE(js_cc_scene_FogInfo_fogDensity_get), _SE(js_cc_scene_FogInfo_fogDensity_set)); + cls->defineProperty("fogStart", _SE(js_cc_scene_FogInfo_fogStart_get), _SE(js_cc_scene_FogInfo_fogStart_set)); + cls->defineProperty("fogEnd", _SE(js_cc_scene_FogInfo_fogEnd_get), _SE(js_cc_scene_FogInfo_fogEnd_set)); + cls->defineProperty("fogAtten", _SE(js_cc_scene_FogInfo_fogAtten_get), _SE(js_cc_scene_FogInfo_fogAtten_set)); + cls->defineProperty("fogTop", _SE(js_cc_scene_FogInfo_fogTop_get), _SE(js_cc_scene_FogInfo_fogTop_set)); + cls->defineProperty("fogRange", _SE(js_cc_scene_FogInfo_fogRange_get), _SE(js_cc_scene_FogInfo_fogRange_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_FogInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_FogInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_FogInfo_proto = cls->getProto(); + __jsb_cc_scene_FogInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_ShadowsInfo_class = nullptr; +se::Object* __jsb_cc_scene_ShadowsInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_ShadowsInfo) + +static bool js_new_cc_scene_ShadowsInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::ShadowsInfo *result; + result = (cc::scene::ShadowsInfo *)new cc::scene::ShadowsInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_ShadowsInfo, __jsb_cc_scene_ShadowsInfo_class, js_delete_cc_scene_ShadowsInfo) + +static bool js_delete_cc_scene_ShadowsInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_ShadowsInfo) + +static bool js_cc_scene_ShadowsInfo_setPlaneFromNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setPlaneFromNode((cc::Node const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ShadowsInfo_setPlaneFromNode) + +static bool js_cc_scene_ShadowsInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::scene::Shadows *arg2 = (cc::scene::Shadows *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ShadowsInfo_activate) + +static bool js_cc_scene_ShadowsInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__enabled_set) + +static bool js_cc_scene_ShadowsInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__enabled_get) + +static bool js_cc_scene_ShadowsInfo__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__type_set) + +static bool js_cc_scene_ShadowsInfo__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__type_get) + +static bool js_cc_scene_ShadowsInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__resource_set) + +static bool js_cc_scene_ShadowsInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__resource_get) + +static bool js_cc_scene_ShadowsInfo__maxReceived_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_maxReceived, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__maxReceived_set) + +static bool js_cc_scene_ShadowsInfo__maxReceived_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_maxReceived, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__maxReceived_get) + +static bool js_cc_scene_ShadowsInfo__distance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_distance, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__distance_set) + +static bool js_cc_scene_ShadowsInfo__distance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_distance, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__distance_get) + +static bool js_cc_scene_ShadowsInfo__planeBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_planeBias, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__planeBias_set) + +static bool js_cc_scene_ShadowsInfo__planeBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_planeBias, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__planeBias_get) + +static bool js_cc_scene_ShadowsInfo__size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_size, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__size_set) + +static bool js_cc_scene_ShadowsInfo__size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_size, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_size, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__size_get) + +static bool js_cc_scene_ShadowsInfo__normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_normal, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__normal_set) + +static bool js_cc_scene_ShadowsInfo__normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_normal, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_normal, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__normal_get) + +static bool js_cc_scene_ShadowsInfo__shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_shadowColor, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo__shadowColor_set) + +static bool js_cc_scene_ShadowsInfo__shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_shadowColor, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_shadowColor, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo__shadowColor_get) + +static bool js_cc_scene_ShadowsInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_enabled_set) + +static bool js_cc_scene_ShadowsInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_ShadowsInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_enabled_get) + +static bool js_cc_scene_ShadowsInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::scene::ShadowType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ShadowsInfo_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_type_set) + +static bool js_cc_scene_ShadowsInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::scene::ShadowType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ShadowType)cc_scene_ShadowsInfo_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_type_get) + +static bool js_cc_scene_ShadowsInfo_shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ShadowsInfo_shadowColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_shadowColor_set) + +static bool js_cc_scene_ShadowsInfo_shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_ShadowsInfo_shadowColor_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_scene_ShadowsInfo_shadowColor_get) + +static bool js_cc_scene_ShadowsInfo_planeDirection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ShadowsInfo_planeDirection_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_planeDirection_set) + +static bool js_cc_scene_ShadowsInfo_planeDirection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_ShadowsInfo_planeDirection_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_scene_ShadowsInfo_planeDirection_get) + +static bool js_cc_scene_ShadowsInfo_planeHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_planeHeight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_planeHeight_set) + +static bool js_cc_scene_ShadowsInfo_planeHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_ShadowsInfo_planeHeight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_planeHeight_get) + +static bool js_cc_scene_ShadowsInfo_planeBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_planeBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_planeBias_set) + +static bool js_cc_scene_ShadowsInfo_planeBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_ShadowsInfo_planeBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_planeBias_get) + +static bool js_cc_scene_ShadowsInfo_maxReceived_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ShadowsInfo_maxReceived_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_maxReceived_set) + +static bool js_cc_scene_ShadowsInfo_maxReceived_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ShadowsInfo_maxReceived_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_maxReceived_get) + +static bool js_cc_scene_ShadowsInfo_shadowMapSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ShadowsInfo_shadowMapSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ShadowsInfo_shadowMapSize_set) + +static bool js_cc_scene_ShadowsInfo_shadowMapSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ShadowsInfo *arg1 = (cc::scene::ShadowsInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_ShadowsInfo_shadowMapSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ShadowsInfo_shadowMapSize_get) + +bool js_register_cc_scene_ShadowsInfo(se::Object* obj) { + auto* cls = se::Class::create("ShadowsInfo", obj, nullptr, _SE(js_new_cc_scene_ShadowsInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_enabled", _SE(js_cc_scene_ShadowsInfo__enabled_get), _SE(js_cc_scene_ShadowsInfo__enabled_set)); + cls->defineProperty("_type", _SE(js_cc_scene_ShadowsInfo__type_get), _SE(js_cc_scene_ShadowsInfo__type_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_ShadowsInfo__resource_get), _SE(js_cc_scene_ShadowsInfo__resource_set)); + cls->defineProperty("_maxReceived", _SE(js_cc_scene_ShadowsInfo__maxReceived_get), _SE(js_cc_scene_ShadowsInfo__maxReceived_set)); + cls->defineProperty("_distance", _SE(js_cc_scene_ShadowsInfo__distance_get), _SE(js_cc_scene_ShadowsInfo__distance_set)); + cls->defineProperty("_planeBias", _SE(js_cc_scene_ShadowsInfo__planeBias_get), _SE(js_cc_scene_ShadowsInfo__planeBias_set)); + cls->defineProperty("_size", _SE(js_cc_scene_ShadowsInfo__size_get), _SE(js_cc_scene_ShadowsInfo__size_set)); + cls->defineProperty("_normal", _SE(js_cc_scene_ShadowsInfo__normal_get), _SE(js_cc_scene_ShadowsInfo__normal_set)); + cls->defineProperty("_shadowColor", _SE(js_cc_scene_ShadowsInfo__shadowColor_get), _SE(js_cc_scene_ShadowsInfo__shadowColor_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_ShadowsInfo_enabled_get), _SE(js_cc_scene_ShadowsInfo_enabled_set)); + cls->defineProperty("type", _SE(js_cc_scene_ShadowsInfo_type_get), _SE(js_cc_scene_ShadowsInfo_type_set)); + cls->defineProperty("shadowColor", _SE(js_cc_scene_ShadowsInfo_shadowColor_get), _SE(js_cc_scene_ShadowsInfo_shadowColor_set)); + cls->defineProperty("planeDirection", _SE(js_cc_scene_ShadowsInfo_planeDirection_get), _SE(js_cc_scene_ShadowsInfo_planeDirection_set)); + cls->defineProperty("planeHeight", _SE(js_cc_scene_ShadowsInfo_planeHeight_get), _SE(js_cc_scene_ShadowsInfo_planeHeight_set)); + cls->defineProperty("planeBias", _SE(js_cc_scene_ShadowsInfo_planeBias_get), _SE(js_cc_scene_ShadowsInfo_planeBias_set)); + cls->defineProperty("maxReceived", _SE(js_cc_scene_ShadowsInfo_maxReceived_get), _SE(js_cc_scene_ShadowsInfo_maxReceived_set)); + cls->defineProperty("shadowMapSize", _SE(js_cc_scene_ShadowsInfo_shadowMapSize_get), _SE(js_cc_scene_ShadowsInfo_shadowMapSize_set)); + + cls->defineFunction("setPlaneFromNode", _SE(js_cc_scene_ShadowsInfo_setPlaneFromNode)); + cls->defineFunction("activate", _SE(js_cc_scene_ShadowsInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_ShadowsInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_ShadowsInfo_proto = cls->getProto(); + __jsb_cc_scene_ShadowsInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Shadows_class = nullptr; +se::Object* __jsb_cc_scene_Shadows_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Shadows) + +static bool js_new_cc_scene_Shadows(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Shadows *result; + result = (cc::scene::Shadows *)new cc::scene::Shadows(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Shadows, __jsb_cc_scene_Shadows_class, js_delete_cc_scene_Shadows) + +static bool js_delete_cc_scene_Shadows(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Shadows) + +static bool js_cc_scene_Shadows_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::scene::ShadowsInfo *arg2 = 0 ; + cc::scene::ShadowsInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::ShadowsInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_initialize) + +static bool js_cc_scene_Shadows_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_destroy) + +static bool js_cc_scene_Shadows_getPlanarShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + cc::gfx::Shader *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(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::gfx::Shader *)(arg1)->getPlanarShader((ccstd::vector< cc::scene::IMacroPatch > 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_scene_Shadows_getPlanarShader) + +static bool js_cc_scene_Shadows_getPlanarInstanceShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + cc::gfx::Shader *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(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::gfx::Shader *)(arg1)->getPlanarInstanceShader((ccstd::vector< cc::scene::IMacroPatch > 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_scene_Shadows_getPlanarInstanceShader) + +static bool js_cc_scene_Shadows_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_activate) + +static bool js_cc_scene_Shadows_getShadowColor4f(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + ccstd::array< float,4 > *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(s); + if (nullptr == arg1) return true; + result = (ccstd::array< float,4 > *) &((cc::scene::Shadows const *)arg1)->getShadowColor4f(); + + 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_scene_Shadows_getShadowColor4f) + +static bool js_cc_scene_Shadows_setShadowMapSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setShadowMapSize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_setShadowMapSize) + +static bool js_cc_scene_Shadows_getShadowMapSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::Shadows const *)arg1)->getShadowMapSize(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Shadows_getShadowMapSize) + +static bool js_cc_scene_Shadows_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_enabled_set) + +static bool js_cc_scene_Shadows_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Shadows_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_enabled_get) + +static bool js_cc_scene_Shadows_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::scene::ShadowType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Shadows_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_type_set) + +static bool js_cc_scene_Shadows_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::scene::ShadowType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ShadowType)cc_scene_Shadows_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_type_get) + +static bool js_cc_scene_Shadows_normal_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Shadows_normal_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_normal_set) + +static bool js_cc_scene_Shadows_normal_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Shadows_normal_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_scene_Shadows_normal_get) + +static bool js_cc_scene_Shadows_distance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_distance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_distance_set) + +static bool js_cc_scene_Shadows_distance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Shadows_distance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_distance_get) + +static bool js_cc_scene_Shadows_planeBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_planeBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_planeBias_set) + +static bool js_cc_scene_Shadows_planeBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Shadows_planeBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_planeBias_get) + +static bool js_cc_scene_Shadows_shadowColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Shadows_shadowColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_shadowColor_set) + +static bool js_cc_scene_Shadows_shadowColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_Shadows_shadowColor_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_scene_Shadows_shadowColor_get) + +static bool js_cc_scene_Shadows_maxReceived_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Shadows_maxReceived_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_maxReceived_set) + +static bool js_cc_scene_Shadows_maxReceived_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Shadows_maxReceived_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_maxReceived_get) + +static bool js_cc_scene_Shadows_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec2 *arg2 = 0 ; + cc::Vec2 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Shadows_size_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_size_set) + +static bool js_cc_scene_Shadows_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Vec2 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec2 *) &cc_scene_Shadows_size_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_scene_Shadows_size_get) + +static bool js_cc_scene_Shadows_shadowMapDirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Shadows_shadowMapDirty_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Shadows_shadowMapDirty_set) + +static bool js_cc_scene_Shadows_shadowMapDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Shadows_shadowMapDirty_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Shadows_shadowMapDirty_get) + +static bool js_cc_scene_Shadows_matLight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Mat4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Mat4 *) &cc_scene_Shadows_matLight_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_scene_Shadows_matLight_get) + +static bool js_cc_scene_Shadows_material_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_scene_Shadows_material_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_scene_Shadows_material_get) + +static bool js_cc_scene_Shadows_instancingMaterial_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Shadows *arg1 = (cc::scene::Shadows *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_scene_Shadows_instancingMaterial_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_scene_Shadows_instancingMaterial_get) + +bool js_register_cc_scene_Shadows(se::Object* obj) { + auto* cls = se::Class::create("Shadows", obj, nullptr, _SE(js_new_cc_scene_Shadows)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enabled", _SE(js_cc_scene_Shadows_enabled_get), _SE(js_cc_scene_Shadows_enabled_set)); + cls->defineProperty("type", _SE(js_cc_scene_Shadows_type_get), _SE(js_cc_scene_Shadows_type_set)); + cls->defineProperty("normal", _SE(js_cc_scene_Shadows_normal_get), _SE(js_cc_scene_Shadows_normal_set)); + cls->defineProperty("distance", _SE(js_cc_scene_Shadows_distance_get), _SE(js_cc_scene_Shadows_distance_set)); + cls->defineProperty("planeBias", _SE(js_cc_scene_Shadows_planeBias_get), _SE(js_cc_scene_Shadows_planeBias_set)); + cls->defineProperty("shadowColor", _SE(js_cc_scene_Shadows_shadowColor_get), _SE(js_cc_scene_Shadows_shadowColor_set)); + cls->defineProperty("maxReceived", _SE(js_cc_scene_Shadows_maxReceived_get), _SE(js_cc_scene_Shadows_maxReceived_set)); + cls->defineProperty("size", _SE(js_cc_scene_Shadows_size_get), _SE(js_cc_scene_Shadows_size_set)); + cls->defineProperty("shadowMapDirty", _SE(js_cc_scene_Shadows_shadowMapDirty_get), _SE(js_cc_scene_Shadows_shadowMapDirty_set)); + cls->defineProperty("matLight", _SE(js_cc_scene_Shadows_matLight_get), nullptr); + cls->defineProperty("material", _SE(js_cc_scene_Shadows_material_get), nullptr); + cls->defineProperty("instancingMaterial", _SE(js_cc_scene_Shadows_instancingMaterial_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Shadows_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_Shadows_destroy)); + cls->defineFunction("getPlanarShader", _SE(js_cc_scene_Shadows_getPlanarShader)); + cls->defineFunction("getPlanarInstanceShader", _SE(js_cc_scene_Shadows_getPlanarInstanceShader)); + cls->defineFunction("activate", _SE(js_cc_scene_Shadows_activate)); + cls->defineFunction("getShadowColor4f", _SE(js_cc_scene_Shadows_getShadowColor4f)); + cls->defineFunction("setShadowMapSize", _SE(js_cc_scene_Shadows_setShadowMapSize)); + cls->defineFunction("getShadowMapSize", _SE(js_cc_scene_Shadows_getShadowMapSize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Shadows)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Shadows_proto = cls->getProto(); + __jsb_cc_scene_Shadows_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SkyboxInfo_class = nullptr; +se::Object* __jsb_cc_scene_SkyboxInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SkyboxInfo) + +static bool js_new_cc_scene_SkyboxInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SkyboxInfo *result; + result = (cc::scene::SkyboxInfo *)new cc::scene::SkyboxInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SkyboxInfo, __jsb_cc_scene_SkyboxInfo_class, js_delete_cc_scene_SkyboxInfo) + +static bool js_delete_cc_scene_SkyboxInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SkyboxInfo) + +static bool js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + ccstd::string *arg2 = 0 ; + cc::MaterialPropertyVariant *arg3 = 0 ; + index_t arg4 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + ((cc::scene::SkyboxInfo const *)arg1)->setMaterialProperty((ccstd::string const &)*arg2,(cc::MaterialPropertyVariant const &)*arg3,arg4); + + + return true; +} + +static bool js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + ccstd::string *arg2 = 0 ; + cc::MaterialPropertyVariant *arg3 = 0 ; + ccstd::string temp2 ; + cc::MaterialPropertyVariant temp3 ; + + arg1 = SE_THIS_OBJECT(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; + + ((cc::scene::SkyboxInfo const *)arg1)->setMaterialProperty((ccstd::string const &)*arg2,(cc::MaterialPropertyVariant const &)*arg3); + + + return true; +} + +static bool js_cc_scene_SkyboxInfo_setMaterialProperty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_SkyboxInfo_setMaterialProperty__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_SkyboxInfo_setMaterialProperty) + +static bool js_cc_scene_SkyboxInfo_updateEnvMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateEnvMap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkyboxInfo_updateEnvMap) + +static bool js_cc_scene_SkyboxInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::scene::Skybox *arg2 = (cc::scene::Skybox *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkyboxInfo_activate) + +static bool js_cc_scene_SkyboxInfo__envmapHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_envmapHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envmapHDR_set) + +static bool js_cc_scene_SkyboxInfo__envmapHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_envmapHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_envmapHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__envmapHDR_get) + +static bool js_cc_scene_SkyboxInfo__envmapLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_envmapLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envmapLDR_set) + +static bool js_cc_scene_SkyboxInfo__envmapLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_envmapLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_envmapLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__envmapLDR_get) + +static bool js_cc_scene_SkyboxInfo__diffuseMapHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_diffuseMapHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__diffuseMapHDR_set) + +static bool js_cc_scene_SkyboxInfo__diffuseMapHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_diffuseMapHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_diffuseMapHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__diffuseMapHDR_get) + +static bool js_cc_scene_SkyboxInfo__diffuseMapLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_diffuseMapLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__diffuseMapLDR_set) + +static bool js_cc_scene_SkyboxInfo__diffuseMapLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_diffuseMapLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_diffuseMapLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__diffuseMapLDR_get) + +static bool js_cc_scene_SkyboxInfo__reflectionHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reflectionHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__reflectionHDR_set) + +static bool js_cc_scene_SkyboxInfo__reflectionHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reflectionHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_reflectionHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__reflectionHDR_get) + +static bool js_cc_scene_SkyboxInfo__reflectionLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_reflectionLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__reflectionLDR_set) + +static bool js_cc_scene_SkyboxInfo__reflectionLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_reflectionLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_reflectionLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__reflectionLDR_get) + +static bool js_cc_scene_SkyboxInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__enabled_set) + +static bool js_cc_scene_SkyboxInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__enabled_get) + +static bool js_cc_scene_SkyboxInfo__useHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_useHDR); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__useHDR_set) + +static bool js_cc_scene_SkyboxInfo__useHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_useHDR, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__useHDR_get) + +static bool js_cc_scene_SkyboxInfo__envLightingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_envLightingType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envLightingType_set) + +static bool js_cc_scene_SkyboxInfo__envLightingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_envLightingType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_envLightingType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__envLightingType_get) + +static bool js_cc_scene_SkyboxInfo__editableMaterial_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_editableMaterial, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__editableMaterial_set) + +static bool js_cc_scene_SkyboxInfo__editableMaterial_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_editableMaterial, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_editableMaterial, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__editableMaterial_get) + +static bool js_cc_scene_SkyboxInfo__rotationAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_rotationAngle, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__rotationAngle_set) + +static bool js_cc_scene_SkyboxInfo__rotationAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_rotationAngle, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__rotationAngle_get) + +static bool js_cc_scene_SkyboxInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__resource_set) + +static bool js_cc_scene_SkyboxInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo__resource_get) + +static bool js_cc_scene_SkyboxInfo__envmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo__envmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo__envmap_set) + +static bool js_cc_scene_SkyboxInfo__envmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo__envmap_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_scene_SkyboxInfo__envmap_get) + +static bool js_cc_scene_SkyboxInfo_applyDiffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_applyDiffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_applyDiffuseMap_set) + +static bool js_cc_scene_SkyboxInfo_applyDiffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_applyDiffuseMap_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_applyDiffuseMap_get) + +static bool js_cc_scene_SkyboxInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_enabled_set) + +static bool js_cc_scene_SkyboxInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_enabled_get) + +static bool js_cc_scene_SkyboxInfo_useIBL_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_useIBL_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_useIBL_set) + +static bool js_cc_scene_SkyboxInfo_useIBL_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_useIBL_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_useIBL_get) + +static bool js_cc_scene_SkyboxInfo_useHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_useHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_useHDR_set) + +static bool js_cc_scene_SkyboxInfo_useHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SkyboxInfo_useHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_useHDR_get) + +static bool js_cc_scene_SkyboxInfo_envmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_envmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_envmap_set) + +static bool js_cc_scene_SkyboxInfo_envmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo_envmap_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_scene_SkyboxInfo_envmap_get) + +static bool js_cc_scene_SkyboxInfo_diffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_diffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_diffuseMap_set) + +static bool js_cc_scene_SkyboxInfo_diffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo_diffuseMap_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_scene_SkyboxInfo_diffuseMap_get) + +static bool js_cc_scene_SkyboxInfo_reflectionMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_reflectionMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_reflectionMap_set) + +static bool js_cc_scene_SkyboxInfo_reflectionMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_SkyboxInfo_reflectionMap_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_scene_SkyboxInfo_reflectionMap_get) + +static bool js_cc_scene_SkyboxInfo_skyboxMaterial_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_skyboxMaterial_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_skyboxMaterial_set) + +static bool js_cc_scene_SkyboxInfo_skyboxMaterial_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::Material *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Material *)cc_scene_SkyboxInfo_skyboxMaterial_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_scene_SkyboxInfo_skyboxMaterial_get) + +static bool js_cc_scene_SkyboxInfo_rotationAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SkyboxInfo_rotationAngle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_rotationAngle_set) + +static bool js_cc_scene_SkyboxInfo_rotationAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SkyboxInfo_rotationAngle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkyboxInfo_rotationAngle_get) + +static bool js_cc_scene_SkyboxInfo_envLightingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::scene::EnvironmentLightingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_SkyboxInfo_envLightingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkyboxInfo_envLightingType_set) + +static bool js_cc_scene_SkyboxInfo_envLightingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkyboxInfo *arg1 = (cc::scene::SkyboxInfo *) NULL ; + cc::scene::EnvironmentLightingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::EnvironmentLightingType)cc_scene_SkyboxInfo_envLightingType_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_scene_SkyboxInfo_envLightingType_get) + +bool js_register_cc_scene_SkyboxInfo(se::Object* obj) { + auto* cls = se::Class::create("SkyboxInfo", obj, nullptr, _SE(js_new_cc_scene_SkyboxInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_envmapHDR", _SE(js_cc_scene_SkyboxInfo__envmapHDR_get), _SE(js_cc_scene_SkyboxInfo__envmapHDR_set)); + cls->defineProperty("_envmapLDR", _SE(js_cc_scene_SkyboxInfo__envmapLDR_get), _SE(js_cc_scene_SkyboxInfo__envmapLDR_set)); + cls->defineProperty("_diffuseMapHDR", _SE(js_cc_scene_SkyboxInfo__diffuseMapHDR_get), _SE(js_cc_scene_SkyboxInfo__diffuseMapHDR_set)); + cls->defineProperty("_diffuseMapLDR", _SE(js_cc_scene_SkyboxInfo__diffuseMapLDR_get), _SE(js_cc_scene_SkyboxInfo__diffuseMapLDR_set)); + cls->defineProperty("_reflectionHDR", _SE(js_cc_scene_SkyboxInfo__reflectionHDR_get), _SE(js_cc_scene_SkyboxInfo__reflectionHDR_set)); + cls->defineProperty("_reflectionLDR", _SE(js_cc_scene_SkyboxInfo__reflectionLDR_get), _SE(js_cc_scene_SkyboxInfo__reflectionLDR_set)); + cls->defineProperty("_enabled", _SE(js_cc_scene_SkyboxInfo__enabled_get), _SE(js_cc_scene_SkyboxInfo__enabled_set)); + cls->defineProperty("_useHDR", _SE(js_cc_scene_SkyboxInfo__useHDR_get), _SE(js_cc_scene_SkyboxInfo__useHDR_set)); + cls->defineProperty("_envLightingType", _SE(js_cc_scene_SkyboxInfo__envLightingType_get), _SE(js_cc_scene_SkyboxInfo__envLightingType_set)); + cls->defineProperty("_editableMaterial", _SE(js_cc_scene_SkyboxInfo__editableMaterial_get), _SE(js_cc_scene_SkyboxInfo__editableMaterial_set)); + cls->defineProperty("_rotationAngle", _SE(js_cc_scene_SkyboxInfo__rotationAngle_get), _SE(js_cc_scene_SkyboxInfo__rotationAngle_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_SkyboxInfo__resource_get), _SE(js_cc_scene_SkyboxInfo__resource_set)); + cls->defineProperty("_envmap", _SE(js_cc_scene_SkyboxInfo__envmap_get), _SE(js_cc_scene_SkyboxInfo__envmap_set)); + cls->defineProperty("applyDiffuseMap", _SE(js_cc_scene_SkyboxInfo_applyDiffuseMap_get), _SE(js_cc_scene_SkyboxInfo_applyDiffuseMap_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_SkyboxInfo_enabled_get), _SE(js_cc_scene_SkyboxInfo_enabled_set)); + cls->defineProperty("useIBL", _SE(js_cc_scene_SkyboxInfo_useIBL_get), _SE(js_cc_scene_SkyboxInfo_useIBL_set)); + cls->defineProperty("useHDR", _SE(js_cc_scene_SkyboxInfo_useHDR_get), _SE(js_cc_scene_SkyboxInfo_useHDR_set)); + cls->defineProperty("envmap", _SE(js_cc_scene_SkyboxInfo_envmap_get), _SE(js_cc_scene_SkyboxInfo_envmap_set)); + cls->defineProperty("diffuseMap", _SE(js_cc_scene_SkyboxInfo_diffuseMap_get), _SE(js_cc_scene_SkyboxInfo_diffuseMap_set)); + cls->defineProperty("reflectionMap", _SE(js_cc_scene_SkyboxInfo_reflectionMap_get), _SE(js_cc_scene_SkyboxInfo_reflectionMap_set)); + cls->defineProperty("skyboxMaterial", _SE(js_cc_scene_SkyboxInfo_skyboxMaterial_get), _SE(js_cc_scene_SkyboxInfo_skyboxMaterial_set)); + cls->defineProperty("rotationAngle", _SE(js_cc_scene_SkyboxInfo_rotationAngle_get), _SE(js_cc_scene_SkyboxInfo_rotationAngle_set)); + cls->defineProperty("envLightingType", _SE(js_cc_scene_SkyboxInfo_envLightingType_get), _SE(js_cc_scene_SkyboxInfo_envLightingType_set)); + + cls->defineFunction("setMaterialProperty", _SE(js_cc_scene_SkyboxInfo_setMaterialProperty)); + cls->defineFunction("updateEnvMap", _SE(js_cc_scene_SkyboxInfo_updateEnvMap)); + cls->defineFunction("activate", _SE(js_cc_scene_SkyboxInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SkyboxInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SkyboxInfo_proto = cls->getProto(); + __jsb_cc_scene_SkyboxInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Skybox_class = nullptr; +se::Object* __jsb_cc_scene_Skybox_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Skybox) + +static bool js_new_cc_scene_Skybox(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Skybox *result; + result = (cc::scene::Skybox *)new cc::scene::Skybox(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Skybox, __jsb_cc_scene_Skybox_class, js_delete_cc_scene_Skybox) + +static bool js_delete_cc_scene_Skybox(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Skybox) + +static bool js_cc_scene_Skybox_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::scene::SkyboxInfo *arg2 = 0 ; + cc::scene::SkyboxInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::SkyboxInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_initialize) + +static bool js_cc_scene_Skybox_setEnvMaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + cc::TextureCube *arg3 = (cc::TextureCube *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEnvMaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setEnvMaps) + +static bool js_cc_scene_Skybox_setDiffuseMaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + cc::TextureCube *arg3 = (cc::TextureCube *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDiffuseMaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setDiffuseMaps) + +static bool js_cc_scene_Skybox_setReflectionMaps(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + cc::TextureCube *arg3 = (cc::TextureCube *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setReflectionMaps(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setReflectionMaps) + +static bool js_cc_scene_Skybox_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_activate) + +static bool js_cc_scene_Skybox_isUsingConvolutionMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Skybox const *)arg1)->isUsingConvolutionMap(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_isUsingConvolutionMap) + +static bool js_cc_scene_Skybox_setSkyboxMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSkyboxMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setSkyboxMaterial) + +static bool js_cc_scene_Skybox_getSkyboxMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::Material *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(s); + if (nullptr == arg1) return true; + result = (cc::Material *)((cc::scene::Skybox const *)arg1)->getSkyboxMaterial(); + + 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_scene_Skybox_getSkyboxMaterial) + +static bool js_cc_scene_Skybox_setRotationAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRotationAngle(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_setRotationAngle) + +static bool js_cc_scene_Skybox_getRotationAngle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::Skybox const *)arg1)->getRotationAngle(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skybox_getRotationAngle) + +static bool js_cc_scene_Skybox_getReflectionMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *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(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)((cc::scene::Skybox const *)arg1)->getReflectionMap(); + + 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_scene_Skybox_getReflectionMap) + +static bool js_cc_scene_Skybox_model_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::scene::Model *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)cc_scene_Skybox_model_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_scene_Skybox_model_get) + +static bool js_cc_scene_Skybox_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_enabled_set) + +static bool js_cc_scene_Skybox_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_enabled_get) + +static bool js_cc_scene_Skybox_useHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_useHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_useHDR_set) + +static bool js_cc_scene_Skybox_useHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_useHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_useHDR_get) + +static bool js_cc_scene_Skybox_useIBL_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_useIBL_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_useIBL_set) + +static bool js_cc_scene_Skybox_useIBL_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_useIBL_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_useIBL_get) + +static bool js_cc_scene_Skybox_useDiffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_useDiffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_useDiffuseMap_set) + +static bool js_cc_scene_Skybox_useDiffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_useDiffuseMap_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_useDiffuseMap_get) + +static bool js_cc_scene_Skybox_isRGBE_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skybox_isRGBE_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skybox_isRGBE_get) + +static bool js_cc_scene_Skybox_envmap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_envmap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_envmap_set) + +static bool js_cc_scene_Skybox_envmap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_Skybox_envmap_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_scene_Skybox_envmap_get) + +static bool js_cc_scene_Skybox_diffuseMap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skybox_diffuseMap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skybox_diffuseMap_set) + +static bool js_cc_scene_Skybox_diffuseMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skybox *arg1 = (cc::scene::Skybox *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_Skybox_diffuseMap_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_scene_Skybox_diffuseMap_get) + +bool js_register_cc_scene_Skybox(se::Object* obj) { + auto* cls = se::Class::create("Skybox", obj, nullptr, _SE(js_new_cc_scene_Skybox)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("model", _SE(js_cc_scene_Skybox_model_get), nullptr); + cls->defineProperty("enabled", _SE(js_cc_scene_Skybox_enabled_get), _SE(js_cc_scene_Skybox_enabled_set)); + cls->defineProperty("useHDR", _SE(js_cc_scene_Skybox_useHDR_get), _SE(js_cc_scene_Skybox_useHDR_set)); + cls->defineProperty("useIBL", _SE(js_cc_scene_Skybox_useIBL_get), _SE(js_cc_scene_Skybox_useIBL_set)); + cls->defineProperty("useDiffuseMap", _SE(js_cc_scene_Skybox_useDiffuseMap_get), _SE(js_cc_scene_Skybox_useDiffuseMap_set)); + cls->defineProperty("isRGBE", _SE(js_cc_scene_Skybox_isRGBE_get), nullptr); + cls->defineProperty("envmap", _SE(js_cc_scene_Skybox_envmap_get), _SE(js_cc_scene_Skybox_envmap_set)); + cls->defineProperty("diffuseMap", _SE(js_cc_scene_Skybox_diffuseMap_get), _SE(js_cc_scene_Skybox_diffuseMap_set)); + + cls->defineFunction("initialize", _SE(js_cc_scene_Skybox_initialize)); + cls->defineFunction("setEnvMaps", _SE(js_cc_scene_Skybox_setEnvMaps)); + cls->defineFunction("setDiffuseMaps", _SE(js_cc_scene_Skybox_setDiffuseMaps)); + cls->defineFunction("setReflectionMaps", _SE(js_cc_scene_Skybox_setReflectionMaps)); + cls->defineFunction("activate", _SE(js_cc_scene_Skybox_activate)); + cls->defineFunction("isUsingConvolutionMap", _SE(js_cc_scene_Skybox_isUsingConvolutionMap)); + cls->defineFunction("setSkyboxMaterial", _SE(js_cc_scene_Skybox_setSkyboxMaterial)); + cls->defineFunction("getSkyboxMaterial", _SE(js_cc_scene_Skybox_getSkyboxMaterial)); + cls->defineFunction("setRotationAngle", _SE(js_cc_scene_Skybox_setRotationAngle)); + cls->defineFunction("getRotationAngle", _SE(js_cc_scene_Skybox_getRotationAngle)); + cls->defineFunction("getReflectionMap", _SE(js_cc_scene_Skybox_getReflectionMap)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Skybox)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Skybox_proto = cls->getProto(); + __jsb_cc_scene_Skybox_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SkinInfo_class = nullptr; +se::Object* __jsb_cc_scene_SkinInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SkinInfo) + +static bool js_new_cc_scene_SkinInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SkinInfo *result; + result = (cc::scene::SkinInfo *)new cc::scene::SkinInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SkinInfo, __jsb_cc_scene_SkinInfo_class, js_delete_cc_scene_SkinInfo) + +static bool js_delete_cc_scene_SkinInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SkinInfo) + +static bool js_cc_scene_SkinInfo_setEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_setEnabled) + +static bool js_cc_scene_SkinInfo_isEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::SkinInfo const *)arg1)->isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_isEnabled) + +static bool js_cc_scene_SkinInfo_setBlurRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBlurRadius(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_setBlurRadius) + +static bool js_cc_scene_SkinInfo_getBlurRadius(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::SkinInfo const *)arg1)->getBlurRadius(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_getBlurRadius) + +static bool js_cc_scene_SkinInfo_setSSSIntensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSSSIntensity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_setSSSIntensity) + +static bool js_cc_scene_SkinInfo_getSSSIntensity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::SkinInfo const *)arg1)->getSSSIntensity(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_getSSSIntensity) + +static bool js_cc_scene_SkinInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + cc::scene::Skin *arg2 = (cc::scene::Skin *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SkinInfo_activate) + +static bool js_cc_scene_SkinInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__enabled_set) + +static bool js_cc_scene_SkinInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__enabled_get) + +static bool js_cc_scene_SkinInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__resource_set) + +static bool js_cc_scene_SkinInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__resource_get) + +static bool js_cc_scene_SkinInfo__blurRadius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_blurRadius, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__blurRadius_set) + +static bool js_cc_scene_SkinInfo__blurRadius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_blurRadius, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__blurRadius_get) + +static bool js_cc_scene_SkinInfo__sssIntensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_sssIntensity, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SkinInfo__sssIntensity_set) + +static bool js_cc_scene_SkinInfo__sssIntensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SkinInfo *arg1 = (cc::scene::SkinInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_sssIntensity, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SkinInfo__sssIntensity_get) + +bool js_register_cc_scene_SkinInfo(se::Object* obj) { + auto* cls = se::Class::create("SkinInfo", obj, nullptr, _SE(js_new_cc_scene_SkinInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_enabled", _SE(js_cc_scene_SkinInfo__enabled_get), _SE(js_cc_scene_SkinInfo__enabled_set)); + cls->defineProperty("_resource", _SE(js_cc_scene_SkinInfo__resource_get), _SE(js_cc_scene_SkinInfo__resource_set)); + cls->defineProperty("_blurRadius", _SE(js_cc_scene_SkinInfo__blurRadius_get), _SE(js_cc_scene_SkinInfo__blurRadius_set)); + cls->defineProperty("_sssIntensity", _SE(js_cc_scene_SkinInfo__sssIntensity_get), _SE(js_cc_scene_SkinInfo__sssIntensity_set)); + + cls->defineFunction("setEnabled", _SE(js_cc_scene_SkinInfo_setEnabled)); + cls->defineFunction("isEnabled", _SE(js_cc_scene_SkinInfo_isEnabled)); + cls->defineFunction("setBlurRadius", _SE(js_cc_scene_SkinInfo_setBlurRadius)); + cls->defineFunction("getBlurRadius", _SE(js_cc_scene_SkinInfo_getBlurRadius)); + cls->defineFunction("setSSSIntensity", _SE(js_cc_scene_SkinInfo_setSSSIntensity)); + cls->defineFunction("getSSSIntensity", _SE(js_cc_scene_SkinInfo_getSSSIntensity)); + cls->defineFunction("activate", _SE(js_cc_scene_SkinInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SkinInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SkinInfo_proto = cls->getProto(); + __jsb_cc_scene_SkinInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Skin_class = nullptr; +se::Object* __jsb_cc_scene_Skin_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Skin) + +static bool js_new_cc_scene_Skin(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Skin *result; + result = (cc::scene::Skin *)new cc::scene::Skin(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Skin, __jsb_cc_scene_Skin_class, js_delete_cc_scene_Skin) + +static bool js_delete_cc_scene_Skin(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Skin) + +static bool js_cc_scene_Skin_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + cc::scene::SkinInfo *arg2 = 0 ; + cc::scene::SkinInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::SkinInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Skin_initialize) + +static bool js_cc_scene_Skin_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skin_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skin_enabled_set) + +static bool js_cc_scene_Skin_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Skin_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skin_enabled_get) + +static bool js_cc_scene_Skin_blurRadius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skin_blurRadius_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skin_blurRadius_set) + +static bool js_cc_scene_Skin_blurRadius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Skin_blurRadius_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skin_blurRadius_get) + +static bool js_cc_scene_Skin_sssIntensity_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Skin_sssIntensity_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Skin_sssIntensity_set) + +static bool js_cc_scene_Skin_sssIntensity_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Skin *arg1 = (cc::scene::Skin *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Skin_sssIntensity_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Skin_sssIntensity_get) + +bool js_register_cc_scene_Skin(se::Object* obj) { + auto* cls = se::Class::create("Skin", obj, nullptr, _SE(js_new_cc_scene_Skin)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("enabled", _SE(js_cc_scene_Skin_enabled_get), _SE(js_cc_scene_Skin_enabled_set)); + cls->defineProperty("blurRadius", _SE(js_cc_scene_Skin_blurRadius_get), _SE(js_cc_scene_Skin_blurRadius_set)); + cls->defineProperty("sssIntensity", _SE(js_cc_scene_Skin_sssIntensity_get), _SE(js_cc_scene_Skin_sssIntensity_set)); + + cls->defineFunction("initialize", _SE(js_cc_scene_Skin_initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Skin)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Skin_proto = cls->getProto(); + __jsb_cc_scene_Skin_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PostSettingsInfo_class = nullptr; +se::Object* __jsb_cc_scene_PostSettingsInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PostSettingsInfo) + +static bool js_new_cc_scene_PostSettingsInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PostSettingsInfo *result; + result = (cc::scene::PostSettingsInfo *)new cc::scene::PostSettingsInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PostSettingsInfo, __jsb_cc_scene_PostSettingsInfo_class, js_delete_cc_scene_PostSettingsInfo) + +static bool js_delete_cc_scene_PostSettingsInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PostSettingsInfo) + +static bool js_cc_scene_PostSettingsInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + cc::scene::PostSettings *arg2 = (cc::scene::PostSettings *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_PostSettingsInfo_activate) + +static bool js_cc_scene_PostSettingsInfo__resource_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_resource, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettingsInfo__resource_set) + +static bool js_cc_scene_PostSettingsInfo__resource_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_resource, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_resource, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PostSettingsInfo__resource_get) + +static bool js_cc_scene_PostSettingsInfo__toneMappingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_toneMappingType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettingsInfo__toneMappingType_set) + +static bool js_cc_scene_PostSettingsInfo__toneMappingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_toneMappingType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_toneMappingType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PostSettingsInfo__toneMappingType_get) + +static bool js_cc_scene_PostSettingsInfo_toneMappingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + cc::scene::ToneMappingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_PostSettingsInfo_toneMappingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettingsInfo_toneMappingType_set) + +static bool js_cc_scene_PostSettingsInfo_toneMappingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettingsInfo *arg1 = (cc::scene::PostSettingsInfo *) NULL ; + cc::scene::ToneMappingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ToneMappingType)cc_scene_PostSettingsInfo_toneMappingType_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_scene_PostSettingsInfo_toneMappingType_get) + +bool js_register_cc_scene_PostSettingsInfo(se::Object* obj) { + auto* cls = se::Class::create("PostSettingsInfo", obj, nullptr, _SE(js_new_cc_scene_PostSettingsInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_resource", _SE(js_cc_scene_PostSettingsInfo__resource_get), _SE(js_cc_scene_PostSettingsInfo__resource_set)); + cls->defineProperty("_toneMappingType", _SE(js_cc_scene_PostSettingsInfo__toneMappingType_get), _SE(js_cc_scene_PostSettingsInfo__toneMappingType_set)); + cls->defineProperty("toneMappingType", _SE(js_cc_scene_PostSettingsInfo_toneMappingType_get), _SE(js_cc_scene_PostSettingsInfo_toneMappingType_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_PostSettingsInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PostSettingsInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PostSettingsInfo_proto = cls->getProto(); + __jsb_cc_scene_PostSettingsInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PostSettings_class = nullptr; +se::Object* __jsb_cc_scene_PostSettings_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PostSettings) + +static bool js_new_cc_scene_PostSettings(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PostSettings *result; + result = (cc::scene::PostSettings *)new cc::scene::PostSettings(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PostSettings, __jsb_cc_scene_PostSettings_class, js_delete_cc_scene_PostSettings) + +static bool js_delete_cc_scene_PostSettings(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PostSettings) + +static bool js_cc_scene_PostSettings_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_PostSettings_activate) + +static bool js_cc_scene_PostSettings_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + cc::scene::PostSettingsInfo *arg2 = 0 ; + cc::scene::PostSettingsInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::PostSettingsInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_PostSettings_initialize) + +static bool js_cc_scene_PostSettings_toneMappingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + cc::scene::ToneMappingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_PostSettings_toneMappingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PostSettings_toneMappingType_set) + +static bool js_cc_scene_PostSettings_toneMappingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PostSettings *arg1 = (cc::scene::PostSettings *) NULL ; + cc::scene::ToneMappingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ToneMappingType)cc_scene_PostSettings_toneMappingType_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_scene_PostSettings_toneMappingType_get) + +bool js_register_cc_scene_PostSettings(se::Object* obj) { + auto* cls = se::Class::create("PostSettings", obj, nullptr, _SE(js_new_cc_scene_PostSettings)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("toneMappingType", _SE(js_cc_scene_PostSettings_toneMappingType_get), _SE(js_cc_scene_PostSettings_toneMappingType_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_PostSettings_activate)); + cls->defineFunction("initialize", _SE(js_cc_scene_PostSettings_initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PostSettings)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PostSettings_proto = cls->getProto(); + __jsb_cc_scene_PostSettings_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_DirectionalLight_class = nullptr; +se::Object* __jsb_cc_scene_DirectionalLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_DirectionalLight) + +static bool js_new_cc_scene_DirectionalLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::DirectionalLight *result; + result = (cc::scene::DirectionalLight *)new cc::scene::DirectionalLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_DirectionalLight, __jsb_cc_scene_DirectionalLight_class, js_delete_cc_scene_DirectionalLight) + +static bool js_delete_cc_scene_DirectionalLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_DirectionalLight) + +static bool js_cc_scene_DirectionalLight_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ((cc::scene::DirectionalLight const *)arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_DirectionalLight_activate) + +static bool js_cc_scene_DirectionalLight_direction_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_DirectionalLight_direction_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_direction_set) + +static bool js_cc_scene_DirectionalLight_direction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_DirectionalLight_direction_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_scene_DirectionalLight_direction_get) + +static bool js_cc_scene_DirectionalLight_illuminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_illuminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_illuminance_set) + +static bool js_cc_scene_DirectionalLight_illuminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_illuminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_illuminance_get) + +static bool js_cc_scene_DirectionalLight_illuminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_illuminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_illuminanceHDR_set) + +static bool js_cc_scene_DirectionalLight_illuminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_illuminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_illuminanceHDR_get) + +static bool js_cc_scene_DirectionalLight_illuminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_illuminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_illuminanceLDR_set) + +static bool js_cc_scene_DirectionalLight_illuminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_illuminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_illuminanceLDR_get) + +static bool js_cc_scene_DirectionalLight_shadowEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowEnabled_set) + +static bool js_cc_scene_DirectionalLight_shadowEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_shadowEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowEnabled_get) + +static bool js_cc_scene_DirectionalLight_shadowPcf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::PCFType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_DirectionalLight_shadowPcf_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowPcf_set) + +static bool js_cc_scene_DirectionalLight_shadowPcf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::PCFType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::PCFType)cc_scene_DirectionalLight_shadowPcf_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_scene_DirectionalLight_shadowPcf_get) + +static bool js_cc_scene_DirectionalLight_shadowBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowBias_set) + +static bool js_cc_scene_DirectionalLight_shadowBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowBias_get) + +static bool js_cc_scene_DirectionalLight_shadowNormalBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowNormalBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowNormalBias_set) + +static bool js_cc_scene_DirectionalLight_shadowNormalBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowNormalBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowNormalBias_get) + +static bool js_cc_scene_DirectionalLight_shadowSaturation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowSaturation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowSaturation_set) + +static bool js_cc_scene_DirectionalLight_shadowSaturation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowSaturation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowSaturation_get) + +static bool js_cc_scene_DirectionalLight_shadowDistance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowDistance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowDistance_set) + +static bool js_cc_scene_DirectionalLight_shadowDistance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowDistance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowDistance_get) + +static bool js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set) + +static bool js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get) + +static bool js_cc_scene_DirectionalLight_shadowFixedArea_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowFixedArea_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowFixedArea_set) + +static bool js_cc_scene_DirectionalLight_shadowFixedArea_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_shadowFixedArea_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowFixedArea_get) + +static bool js_cc_scene_DirectionalLight_shadowNear_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowNear_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowNear_set) + +static bool js_cc_scene_DirectionalLight_shadowNear_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowNear_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowNear_get) + +static bool js_cc_scene_DirectionalLight_shadowFar_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowFar_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowFar_set) + +static bool js_cc_scene_DirectionalLight_shadowFar_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowFar_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowFar_get) + +static bool js_cc_scene_DirectionalLight_shadowOrthoSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_shadowOrthoSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_shadowOrthoSize_set) + +static bool js_cc_scene_DirectionalLight_shadowOrthoSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_shadowOrthoSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_shadowOrthoSize_get) + +static bool js_cc_scene_DirectionalLight_csmLevel_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMLevel arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_DirectionalLight_csmLevel_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmLevel_set) + +static bool js_cc_scene_DirectionalLight_csmLevel_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMLevel result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CSMLevel)cc_scene_DirectionalLight_csmLevel_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_scene_DirectionalLight_csmLevel_get) + +static bool js_cc_scene_DirectionalLight_csmNeedUpdate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmNeedUpdate_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmNeedUpdate_set) + +static bool js_cc_scene_DirectionalLight_csmNeedUpdate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_csmNeedUpdate_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmNeedUpdate_get) + +static bool js_cc_scene_DirectionalLight_csmLayerLambda_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmLayerLambda_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmLayerLambda_set) + +static bool js_cc_scene_DirectionalLight_csmLayerLambda_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_csmLayerLambda_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmLayerLambda_get) + +static bool js_cc_scene_DirectionalLight_csmOptimizationMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMOptimizationMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_DirectionalLight_csmOptimizationMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmOptimizationMode_set) + +static bool js_cc_scene_DirectionalLight_csmOptimizationMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + cc::scene::CSMOptimizationMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CSMOptimizationMode)cc_scene_DirectionalLight_csmOptimizationMode_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_scene_DirectionalLight_csmOptimizationMode_get) + +static bool js_cc_scene_DirectionalLight_csmLayersTransition_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmLayersTransition_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmLayersTransition_set) + +static bool js_cc_scene_DirectionalLight_csmLayersTransition_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_DirectionalLight_csmLayersTransition_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmLayersTransition_get) + +static bool js_cc_scene_DirectionalLight_csmTransitionRange_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_DirectionalLight_csmTransitionRange_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_DirectionalLight_csmTransitionRange_set) + +static bool js_cc_scene_DirectionalLight_csmTransitionRange_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::DirectionalLight *arg1 = (cc::scene::DirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_DirectionalLight_csmTransitionRange_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_DirectionalLight_csmTransitionRange_get) + +bool js_register_cc_scene_DirectionalLight(se::Object* obj) { + auto* cls = se::Class::create("DirectionalLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_DirectionalLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("direction", _SE(js_cc_scene_DirectionalLight_direction_get), _SE(js_cc_scene_DirectionalLight_direction_set)); + cls->defineProperty("illuminance", _SE(js_cc_scene_DirectionalLight_illuminance_get), _SE(js_cc_scene_DirectionalLight_illuminance_set)); + cls->defineProperty("illuminanceHDR", _SE(js_cc_scene_DirectionalLight_illuminanceHDR_get), _SE(js_cc_scene_DirectionalLight_illuminanceHDR_set)); + cls->defineProperty("illuminanceLDR", _SE(js_cc_scene_DirectionalLight_illuminanceLDR_get), _SE(js_cc_scene_DirectionalLight_illuminanceLDR_set)); + cls->defineProperty("shadowEnabled", _SE(js_cc_scene_DirectionalLight_shadowEnabled_get), _SE(js_cc_scene_DirectionalLight_shadowEnabled_set)); + cls->defineProperty("shadowPcf", _SE(js_cc_scene_DirectionalLight_shadowPcf_get), _SE(js_cc_scene_DirectionalLight_shadowPcf_set)); + cls->defineProperty("shadowBias", _SE(js_cc_scene_DirectionalLight_shadowBias_get), _SE(js_cc_scene_DirectionalLight_shadowBias_set)); + cls->defineProperty("shadowNormalBias", _SE(js_cc_scene_DirectionalLight_shadowNormalBias_get), _SE(js_cc_scene_DirectionalLight_shadowNormalBias_set)); + cls->defineProperty("shadowSaturation", _SE(js_cc_scene_DirectionalLight_shadowSaturation_get), _SE(js_cc_scene_DirectionalLight_shadowSaturation_set)); + cls->defineProperty("shadowDistance", _SE(js_cc_scene_DirectionalLight_shadowDistance_get), _SE(js_cc_scene_DirectionalLight_shadowDistance_set)); + cls->defineProperty("shadowInvisibleOcclusionRange", _SE(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_get), _SE(js_cc_scene_DirectionalLight_shadowInvisibleOcclusionRange_set)); + cls->defineProperty("shadowFixedArea", _SE(js_cc_scene_DirectionalLight_shadowFixedArea_get), _SE(js_cc_scene_DirectionalLight_shadowFixedArea_set)); + cls->defineProperty("shadowNear", _SE(js_cc_scene_DirectionalLight_shadowNear_get), _SE(js_cc_scene_DirectionalLight_shadowNear_set)); + cls->defineProperty("shadowFar", _SE(js_cc_scene_DirectionalLight_shadowFar_get), _SE(js_cc_scene_DirectionalLight_shadowFar_set)); + cls->defineProperty("shadowOrthoSize", _SE(js_cc_scene_DirectionalLight_shadowOrthoSize_get), _SE(js_cc_scene_DirectionalLight_shadowOrthoSize_set)); + cls->defineProperty("csmLevel", _SE(js_cc_scene_DirectionalLight_csmLevel_get), _SE(js_cc_scene_DirectionalLight_csmLevel_set)); + cls->defineProperty("csmNeedUpdate", _SE(js_cc_scene_DirectionalLight_csmNeedUpdate_get), _SE(js_cc_scene_DirectionalLight_csmNeedUpdate_set)); + cls->defineProperty("csmLayerLambda", _SE(js_cc_scene_DirectionalLight_csmLayerLambda_get), _SE(js_cc_scene_DirectionalLight_csmLayerLambda_set)); + cls->defineProperty("csmOptimizationMode", _SE(js_cc_scene_DirectionalLight_csmOptimizationMode_get), _SE(js_cc_scene_DirectionalLight_csmOptimizationMode_set)); + cls->defineProperty("csmLayersTransition", _SE(js_cc_scene_DirectionalLight_csmLayersTransition_get), _SE(js_cc_scene_DirectionalLight_csmLayersTransition_set)); + cls->defineProperty("csmTransitionRange", _SE(js_cc_scene_DirectionalLight_csmTransitionRange_get), _SE(js_cc_scene_DirectionalLight_csmTransitionRange_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_DirectionalLight_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_DirectionalLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_DirectionalLight_proto = cls->getProto(); + __jsb_cc_scene_DirectionalLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SpotLight_class = nullptr; +se::Object* __jsb_cc_scene_SpotLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SpotLight) + +static bool js_new_cc_scene_SpotLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SpotLight *result; + result = (cc::scene::SpotLight *)new cc::scene::SpotLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SpotLight, __jsb_cc_scene_SpotLight_class, js_delete_cc_scene_SpotLight) + +static bool js_delete_cc_scene_SpotLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SpotLight) + +static bool js_cc_scene_SpotLight_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_SpotLight_position_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_scene_SpotLight_position_get) + +static bool js_cc_scene_SpotLight_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_range_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_range_set) + +static bool js_cc_scene_SpotLight_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_range_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_range_get) + +static bool js_cc_scene_SpotLight_luminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_luminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_luminance_set) + +static bool js_cc_scene_SpotLight_luminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_luminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_luminance_get) + +static bool js_cc_scene_SpotLight_luminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_luminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_luminanceHDR_set) + +static bool js_cc_scene_SpotLight_luminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_luminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_luminanceHDR_get) + +static bool js_cc_scene_SpotLight_luminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_luminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_luminanceLDR_set) + +static bool js_cc_scene_SpotLight_luminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_luminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_luminanceLDR_get) + +static bool js_cc_scene_SpotLight_direction_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_SpotLight_direction_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_scene_SpotLight_direction_get) + +static bool js_cc_scene_SpotLight_spotAngle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_spotAngle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_spotAngle_set) + +static bool js_cc_scene_SpotLight_spotAngle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_spotAngle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_spotAngle_get) + +static bool js_cc_scene_SpotLight_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_angle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_angle_get) + +static bool js_cc_scene_SpotLight_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &cc_scene_SpotLight_aabb_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_scene_SpotLight_aabb_get) + +static bool js_cc_scene_SpotLight_frustum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SpotLight_frustum_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_frustum_set) + +static bool js_cc_scene_SpotLight_frustum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + cc::geometry::Frustum *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Frustum *) &cc_scene_SpotLight_frustum_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_scene_SpotLight_frustum_get) + +static bool js_cc_scene_SpotLight_shadowEnabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowEnabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowEnabled_set) + +static bool js_cc_scene_SpotLight_shadowEnabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_SpotLight_shadowEnabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowEnabled_get) + +static bool js_cc_scene_SpotLight_shadowPcf_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowPcf_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowPcf_set) + +static bool js_cc_scene_SpotLight_shadowPcf_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_shadowPcf_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowPcf_get) + +static bool js_cc_scene_SpotLight_shadowBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowBias_set) + +static bool js_cc_scene_SpotLight_shadowBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_shadowBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowBias_get) + +static bool js_cc_scene_SpotLight_shadowNormalBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_shadowNormalBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_shadowNormalBias_set) + +static bool js_cc_scene_SpotLight_shadowNormalBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_shadowNormalBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_shadowNormalBias_get) + +static bool js_cc_scene_SpotLight_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_size_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_size_set) + +static bool js_cc_scene_SpotLight_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_size_get) + +static bool js_cc_scene_SpotLight_angleAttenuationStrength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SpotLight_angleAttenuationStrength_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SpotLight_angleAttenuationStrength_set) + +static bool js_cc_scene_SpotLight_angleAttenuationStrength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SpotLight *arg1 = (cc::scene::SpotLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SpotLight_angleAttenuationStrength_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SpotLight_angleAttenuationStrength_get) + +bool js_register_cc_scene_SpotLight(se::Object* obj) { + auto* cls = se::Class::create("SpotLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_SpotLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_scene_SpotLight_position_get), nullptr); + cls->defineProperty("range", _SE(js_cc_scene_SpotLight_range_get), _SE(js_cc_scene_SpotLight_range_set)); + cls->defineProperty("luminance", _SE(js_cc_scene_SpotLight_luminance_get), _SE(js_cc_scene_SpotLight_luminance_set)); + cls->defineProperty("luminanceHDR", _SE(js_cc_scene_SpotLight_luminanceHDR_get), _SE(js_cc_scene_SpotLight_luminanceHDR_set)); + cls->defineProperty("luminanceLDR", _SE(js_cc_scene_SpotLight_luminanceLDR_get), _SE(js_cc_scene_SpotLight_luminanceLDR_set)); + cls->defineProperty("direction", _SE(js_cc_scene_SpotLight_direction_get), nullptr); + cls->defineProperty("spotAngle", _SE(js_cc_scene_SpotLight_spotAngle_get), _SE(js_cc_scene_SpotLight_spotAngle_set)); + cls->defineProperty("angle", _SE(js_cc_scene_SpotLight_angle_get), nullptr); + cls->defineProperty("aabb", _SE(js_cc_scene_SpotLight_aabb_get), nullptr); + cls->defineProperty("frustum", _SE(js_cc_scene_SpotLight_frustum_get), _SE(js_cc_scene_SpotLight_frustum_set)); + cls->defineProperty("shadowEnabled", _SE(js_cc_scene_SpotLight_shadowEnabled_get), _SE(js_cc_scene_SpotLight_shadowEnabled_set)); + cls->defineProperty("shadowPcf", _SE(js_cc_scene_SpotLight_shadowPcf_get), _SE(js_cc_scene_SpotLight_shadowPcf_set)); + cls->defineProperty("shadowBias", _SE(js_cc_scene_SpotLight_shadowBias_get), _SE(js_cc_scene_SpotLight_shadowBias_set)); + cls->defineProperty("shadowNormalBias", _SE(js_cc_scene_SpotLight_shadowNormalBias_get), _SE(js_cc_scene_SpotLight_shadowNormalBias_set)); + cls->defineProperty("size", _SE(js_cc_scene_SpotLight_size_get), _SE(js_cc_scene_SpotLight_size_set)); + cls->defineProperty("angleAttenuationStrength", _SE(js_cc_scene_SpotLight_angleAttenuationStrength_get), _SE(js_cc_scene_SpotLight_angleAttenuationStrength_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SpotLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SpotLight_proto = cls->getProto(); + __jsb_cc_scene_SpotLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SphereLight_class = nullptr; +se::Object* __jsb_cc_scene_SphereLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SphereLight) + +static bool js_new_cc_scene_SphereLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SphereLight *result; + result = (cc::scene::SphereLight *)new cc::scene::SphereLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SphereLight, __jsb_cc_scene_SphereLight_class, js_delete_cc_scene_SphereLight) + +static bool js_delete_cc_scene_SphereLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SphereLight) + +static bool js_cc_scene_SphereLight_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SphereLight_position_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_position_set) + +static bool js_cc_scene_SphereLight_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_SphereLight_position_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_scene_SphereLight_position_get) + +static bool js_cc_scene_SphereLight_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_size_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_size_set) + +static bool js_cc_scene_SphereLight_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_size_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_size_get) + +static bool js_cc_scene_SphereLight_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_range_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_range_set) + +static bool js_cc_scene_SphereLight_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_range_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_range_get) + +static bool js_cc_scene_SphereLight_luminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_luminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_luminance_set) + +static bool js_cc_scene_SphereLight_luminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_luminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_luminance_get) + +static bool js_cc_scene_SphereLight_luminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_luminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_luminanceHDR_set) + +static bool js_cc_scene_SphereLight_luminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_luminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_luminanceHDR_get) + +static bool js_cc_scene_SphereLight_luminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SphereLight_luminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SphereLight_luminanceLDR_set) + +static bool js_cc_scene_SphereLight_luminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_SphereLight_luminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_SphereLight_luminanceLDR_get) + +static bool js_cc_scene_SphereLight_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SphereLight *arg1 = (cc::scene::SphereLight *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &cc_scene_SphereLight_aabb_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_scene_SphereLight_aabb_get) + +bool js_register_cc_scene_SphereLight(se::Object* obj) { + auto* cls = se::Class::create("SphereLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_SphereLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_scene_SphereLight_position_get), _SE(js_cc_scene_SphereLight_position_set)); + cls->defineProperty("size", _SE(js_cc_scene_SphereLight_size_get), _SE(js_cc_scene_SphereLight_size_set)); + cls->defineProperty("range", _SE(js_cc_scene_SphereLight_range_get), _SE(js_cc_scene_SphereLight_range_set)); + cls->defineProperty("luminance", _SE(js_cc_scene_SphereLight_luminance_get), _SE(js_cc_scene_SphereLight_luminance_set)); + cls->defineProperty("luminanceHDR", _SE(js_cc_scene_SphereLight_luminanceHDR_get), _SE(js_cc_scene_SphereLight_luminanceHDR_set)); + cls->defineProperty("luminanceLDR", _SE(js_cc_scene_SphereLight_luminanceLDR_get), _SE(js_cc_scene_SphereLight_luminanceLDR_set)); + cls->defineProperty("aabb", _SE(js_cc_scene_SphereLight_aabb_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SphereLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SphereLight_proto = cls->getProto(); + __jsb_cc_scene_SphereLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PointLight_class = nullptr; +se::Object* __jsb_cc_scene_PointLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PointLight) + +static bool js_new_cc_scene_PointLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PointLight *result; + result = (cc::scene::PointLight *)new cc::scene::PointLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PointLight, __jsb_cc_scene_PointLight_class, js_delete_cc_scene_PointLight) + +static bool js_delete_cc_scene_PointLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PointLight) + +static bool js_cc_scene_PointLight_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_PointLight_position_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_position_set) + +static bool js_cc_scene_PointLight_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_PointLight_position_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_scene_PointLight_position_get) + +static bool js_cc_scene_PointLight_range_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_range_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_range_set) + +static bool js_cc_scene_PointLight_range_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_range_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_range_get) + +static bool js_cc_scene_PointLight_luminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_luminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_luminance_set) + +static bool js_cc_scene_PointLight_luminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_luminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_luminance_get) + +static bool js_cc_scene_PointLight_luminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_luminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_luminanceHDR_set) + +static bool js_cc_scene_PointLight_luminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_luminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_luminanceHDR_get) + +static bool js_cc_scene_PointLight_luminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_PointLight_luminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PointLight_luminanceLDR_set) + +static bool js_cc_scene_PointLight_luminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_PointLight_luminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PointLight_luminanceLDR_get) + +static bool js_cc_scene_PointLight_aabb_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PointLight *arg1 = (cc::scene::PointLight *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *) &cc_scene_PointLight_aabb_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_scene_PointLight_aabb_get) + +bool js_register_cc_scene_PointLight(se::Object* obj) { + auto* cls = se::Class::create("PointLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_PointLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("position", _SE(js_cc_scene_PointLight_position_get), _SE(js_cc_scene_PointLight_position_set)); + cls->defineProperty("range", _SE(js_cc_scene_PointLight_range_get), _SE(js_cc_scene_PointLight_range_set)); + cls->defineProperty("luminance", _SE(js_cc_scene_PointLight_luminance_get), _SE(js_cc_scene_PointLight_luminance_set)); + cls->defineProperty("luminanceHDR", _SE(js_cc_scene_PointLight_luminanceHDR_get), _SE(js_cc_scene_PointLight_luminanceHDR_set)); + cls->defineProperty("luminanceLDR", _SE(js_cc_scene_PointLight_luminanceLDR_get), _SE(js_cc_scene_PointLight_luminanceLDR_set)); + cls->defineProperty("aabb", _SE(js_cc_scene_PointLight_aabb_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PointLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PointLight_proto = cls->getProto(); + __jsb_cc_scene_PointLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_RangedDirectionalLight_class = nullptr; +se::Object* __jsb_cc_scene_RangedDirectionalLight_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_RangedDirectionalLight) + +static bool js_new_cc_scene_RangedDirectionalLight(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::RangedDirectionalLight *result; + result = (cc::scene::RangedDirectionalLight *)new cc::scene::RangedDirectionalLight(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_RangedDirectionalLight, __jsb_cc_scene_RangedDirectionalLight_class, js_delete_cc_scene_RangedDirectionalLight) + +static bool js_delete_cc_scene_RangedDirectionalLight(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_RangedDirectionalLight) + +static bool js_cc_scene_RangedDirectionalLight_getDirection(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getDirection(); + + 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_scene_RangedDirectionalLight_getDirection) + +static bool js_cc_scene_RangedDirectionalLight_getPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getPosition(); + + 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_scene_RangedDirectionalLight_getPosition) + +static bool js_cc_scene_RangedDirectionalLight_getScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getScale(); + + 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_scene_RangedDirectionalLight_getScale) + +static bool js_cc_scene_RangedDirectionalLight_getRight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::RangedDirectionalLight const *)arg1)->getRight(); + + 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_scene_RangedDirectionalLight_getRight) + +static bool js_cc_scene_RangedDirectionalLight_illuminance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_RangedDirectionalLight_illuminance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_RangedDirectionalLight_illuminance_set) + +static bool js_cc_scene_RangedDirectionalLight_illuminance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_RangedDirectionalLight_illuminance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RangedDirectionalLight_illuminance_get) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_RangedDirectionalLight_illuminanceHDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_RangedDirectionalLight_illuminanceHDR_set) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_RangedDirectionalLight_illuminanceHDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RangedDirectionalLight_illuminanceHDR_get) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_RangedDirectionalLight_illuminanceLDR_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_RangedDirectionalLight_illuminanceLDR_set) + +static bool js_cc_scene_RangedDirectionalLight_illuminanceLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RangedDirectionalLight *arg1 = (cc::scene::RangedDirectionalLight *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_RangedDirectionalLight_illuminanceLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RangedDirectionalLight_illuminanceLDR_get) + +bool js_register_cc_scene_RangedDirectionalLight(se::Object* obj) { + auto* cls = se::Class::create("RangedDirectionalLight", obj, __jsb_cc_scene_Light_proto, _SE(js_new_cc_scene_RangedDirectionalLight)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("illuminance", _SE(js_cc_scene_RangedDirectionalLight_illuminance_get), _SE(js_cc_scene_RangedDirectionalLight_illuminance_set)); + cls->defineProperty("illuminanceHDR", _SE(js_cc_scene_RangedDirectionalLight_illuminanceHDR_get), _SE(js_cc_scene_RangedDirectionalLight_illuminanceHDR_set)); + cls->defineProperty("illuminanceLDR", _SE(js_cc_scene_RangedDirectionalLight_illuminanceLDR_get), _SE(js_cc_scene_RangedDirectionalLight_illuminanceLDR_set)); + + cls->defineFunction("getDirection", _SE(js_cc_scene_RangedDirectionalLight_getDirection)); + cls->defineFunction("getPosition", _SE(js_cc_scene_RangedDirectionalLight_getPosition)); + cls->defineFunction("getScale", _SE(js_cc_scene_RangedDirectionalLight_getScale)); + cls->defineFunction("getRight", _SE(js_cc_scene_RangedDirectionalLight_getRight)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_RangedDirectionalLight)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_RangedDirectionalLight_proto = cls->getProto(); + __jsb_cc_scene_RangedDirectionalLight_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Model_class = nullptr; +se::Object* __jsb_cc_scene_Model_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Model) + +static bool js_new_cc_scene_Model(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Model *result; + result = (cc::scene::Model *)new cc::scene::Model(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Model, __jsb_cc_scene_Model_class, js_delete_cc_scene_Model) + +static bool js_delete_cc_scene_Model(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Model) + +static bool js_cc_scene_Model_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_destroy) + +static bool js_cc_scene_Model_initSubModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::RenderingSubMesh *arg3 = (cc::RenderingSubMesh *) NULL ; + cc::Material *arg4 = (cc::Material *) NULL ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initSubModel(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initSubModel) + +static bool js_cc_scene_Model_getMacroPatches(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + ccstd::vector< cc::scene::IMacroPatch > result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (arg1)->getMacroPatches(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_getMacroPatches) + +static bool js_cc_scene_Model_setSubModelMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::Material *arg3 = (cc::Material *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSubModelMaterial(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setSubModelMaterial) + +static bool js_cc_scene_Model__updateInstancedAttributes(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::vector< cc::gfx::Attribute > *arg2 = 0 ; + cc::scene::SubModel *arg3 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::gfx::Attribute > temp2 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateInstancedAttributes((ccstd::vector< cc::gfx::Attribute > const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateInstancedAttributes) + +static bool js_cc_scene_Model_updateTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateTransform(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateTransform) + +static bool js_cc_scene_Model_updateUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->updateUBOs(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateUBOs) + +static bool js_cc_scene_Model__updateLocalDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLocalDescriptors(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateLocalDescriptors) + +static bool js_cc_scene_Model__updateLocalSHDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateLocalSHDescriptors(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateLocalSHDescriptors) + +static bool js_cc_scene_Model__updateWorldBoundDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::gfx::DescriptorSet *arg3 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateWorldBoundDescriptors(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__updateWorldBoundDescriptors) + +static bool js_cc_scene_Model_createBoundingShape(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::optional< cc::Vec3 > *arg2 = 0 ; + ccstd::optional< cc::Vec3 > *arg3 = 0 ; + ccstd::optional< cc::Vec3 > temp2 ; + ccstd::optional< cc::Vec3 > temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->createBoundingShape((ccstd::optional< cc::Vec3 > const &)*arg2,(ccstd::optional< cc::Vec3 > const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_createBoundingShape) + +static bool js_cc_scene_Model_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initialize) + +static bool js_cc_scene_Model_initLightingmap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Texture2D *arg2 = (cc::Texture2D *) NULL ; + cc::Vec4 *arg3 = 0 ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->initLightingmap(arg2,(cc::Vec4 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initLightingmap) + +static bool js_cc_scene_Model__initLocalDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initLocalDescriptors(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__initLocalDescriptors) + +static bool js_cc_scene_Model__initLocalSHDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initLocalSHDescriptors(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model__initLocalSHDescriptors) + +static bool js_cc_scene_Model_initWorldBoundDescriptors(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWorldBoundDescriptors(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_initWorldBoundDescriptors) + +static bool js_cc_scene_Model_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ((cc::scene::Model const *)arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_onGlobalPipelineStateChanged) + +static bool js_cc_scene_Model_onMacroPatchesStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onMacroPatchesStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_onMacroPatchesStateChanged) + +static bool js_cc_scene_Model_onGeometryChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGeometryChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_onGeometryChanged) + +static bool js_cc_scene_Model_setSubModelMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + index_t arg2 ; + cc::RenderingSubMesh *arg3 = (cc::RenderingSubMesh *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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"); + ((cc::scene::Model const *)arg1)->setSubModelMesh(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setSubModelMesh) + +static bool js_cc_scene_Model_setInstancedAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TypedArray *arg3 = 0 ; + ccstd::string temp2 ; + cc::TypedArray temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setInstancedAttribute((ccstd::string const &)*arg2,(cc::TypedArray const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setInstancedAttribute) + +static bool js_cc_scene_Model_updateWorldBound(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldBound(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBound) + +static bool js_cc_scene_Model_updateWorldBoundsForJSSkinningModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateWorldBoundsForJSSkinningModel((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBoundsForJSSkinningModel) + +static bool js_cc_scene_Model_updateWorldBoundsForJSBakedSkinningModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateWorldBoundsForJSBakedSkinningModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBoundsForJSBakedSkinningModel) + +static bool js_cc_scene_Model_updateLightingmap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Texture2D *arg2 = (cc::Texture2D *) NULL ; + cc::Vec4 *arg3 = 0 ; + 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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->updateLightingmap(arg2,(cc::Vec4 const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateLightingmap) + +static bool js_cc_scene_Model_clearSHUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearSHUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_clearSHUBOs) + +static bool js_cc_scene_Model_updateSHUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateSHUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateSHUBOs) + +static bool js_cc_scene_Model_updateWorldBoundUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldBoundUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateWorldBoundUBOs) + +static bool js_cc_scene_Model_updateLocalShadowBias(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateLocalShadowBias(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateLocalShadowBias) + +static bool js_cc_scene_Model_updateReflectionProbeCubemap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbeCubemap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeCubemap) + +static bool js_cc_scene_Model_updateReflectionProbePlanarMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Texture *arg2 = (cc::gfx::Texture *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbePlanarMap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbePlanarMap) + +static bool js_cc_scene_Model_updateReflectionProbeId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateReflectionProbeId(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeId) + +static bool js_cc_scene_Model_updateReflectionProbeDataMap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Texture2D *arg2 = (cc::Texture2D *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbeDataMap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeDataMap) + +static bool js_cc_scene_Model_updateReflectionProbeBlendCubemap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateReflectionProbeBlendCubemap(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_updateReflectionProbeBlendCubemap) + +static bool js_cc_scene_Model_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_attachToScene) + +static bool js_cc_scene_Model_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_detachFromScene) + +static bool js_cc_scene_Model_setLocalSHBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setLocalSHBuffer(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setLocalSHBuffer) + +static bool js_cc_scene_Model_setBounds(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBounds(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setBounds) + +static bool js_cc_scene_Model_showTetrahedron(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Model const *)arg1)->showTetrahedron(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_showTetrahedron) + +static bool js_cc_scene_Model_getLocalSHBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)((cc::scene::Model const *)arg1)->getLocalSHBuffer(); + + 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_scene_Model_getLocalSHBuffer) + +static bool js_cc_scene_Model_getLocalSHData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Float32Array result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Model const *)arg1)->getLocalSHData(); + + 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_scene_Model_getLocalSHData) + +static bool js_cc_scene_Model_invalidateLocalData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->invalidateLocalData(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_invalidateLocalData) + +static bool js_cc_scene_Model_setCalledFromJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCalledFromJS(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_setCalledFromJS) + +static bool js_cc_scene_Model_isModelImplementedInJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Model const *)arg1)->isModelImplementedInJS(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Model_isModelImplementedInJS) + +static bool js_cc_scene_Model_scene_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_scene_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_scene_set) + +static bool js_cc_scene_Model_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_Model_scene_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_scene_Model_scene_get) + +static bool js_cc_scene_Model__subModels_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *) &cc_scene_Model__subModels_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_scene_Model__subModels_get) + +static bool js_cc_scene_Model_subModels_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SubModel > > *) &cc_scene_Model_subModels_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_scene_Model_subModels_get) + +static bool js_cc_scene_Model_inited_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_inited_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_inited_get) + +static bool js_cc_scene_Model__localDataUpdated_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model__localDataUpdated_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model__localDataUpdated_set) + +static bool js_cc_scene_Model__localDataUpdated_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model__localDataUpdated_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model__localDataUpdated_get) + +static bool js_cc_scene_Model__worldBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model__worldBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model__worldBounds_set) + +static bool js_cc_scene_Model__worldBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model__worldBounds_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_scene_Model__worldBounds_get) + +static bool js_cc_scene_Model_worldBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_worldBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_worldBounds_set) + +static bool js_cc_scene_Model_worldBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model_worldBounds_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_scene_Model_worldBounds_get) + +static bool js_cc_scene_Model__modelBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model__modelBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model__modelBounds_set) + +static bool js_cc_scene_Model__modelBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model__modelBounds_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_scene_Model__modelBounds_get) + +static bool js_cc_scene_Model_modelBounds_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_modelBounds_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_modelBounds_set) + +static bool js_cc_scene_Model_modelBounds_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_Model_modelBounds_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_scene_Model_modelBounds_get) + +static bool js_cc_scene_Model_worldBoundBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_worldBoundBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_worldBoundBuffer_set) + +static bool js_cc_scene_Model_worldBoundBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_scene_Model_worldBoundBuffer_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_scene_Model_worldBoundBuffer_get) + +static bool js_cc_scene_Model_localBuffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_localBuffer_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_localBuffer_set) + +static bool js_cc_scene_Model_localBuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::gfx::Buffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Buffer *)cc_scene_Model_localBuffer_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_scene_Model_localBuffer_get) + +static bool js_cc_scene_Model_updateStamp_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_updateStamp_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_updateStamp_get) + +static bool js_cc_scene_Model_receiveShadow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_receiveShadow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_receiveShadow_set) + +static bool js_cc_scene_Model_receiveShadow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_receiveShadow_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_receiveShadow_get) + +static bool js_cc_scene_Model_castShadow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_castShadow_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_castShadow_set) + +static bool js_cc_scene_Model_castShadow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_castShadow_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_castShadow_get) + +static bool js_cc_scene_Model_shadowBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_shadowBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_shadowBias_set) + +static bool js_cc_scene_Model_shadowBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Model_shadowBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_shadowBias_get) + +static bool js_cc_scene_Model_shadowNormalBias_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_shadowNormalBias_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_shadowNormalBias_set) + +static bool js_cc_scene_Model_shadowNormalBias_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Model_shadowNormalBias_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_shadowNormalBias_get) + +static bool js_cc_scene_Model_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_node_set) + +static bool js_cc_scene_Model_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Model_node_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_scene_Model_node_get) + +static bool js_cc_scene_Model_transform_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_transform_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_transform_set) + +static bool js_cc_scene_Model_transform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Model_transform_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_scene_Model_transform_get) + +static bool js_cc_scene_Model_visFlags_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Layers::Enum arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_visFlags_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_visFlags_set) + +static bool js_cc_scene_Model_visFlags_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::Layers::Enum result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Layers::Enum)cc_scene_Model_visFlags_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_scene_Model_visFlags_get) + +static bool js_cc_scene_Model_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_enabled_set) + +static bool js_cc_scene_Model_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_enabled_get) + +static bool js_cc_scene_Model_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::Model::Type arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_type_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_type_set) + +static bool js_cc_scene_Model_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::Model::Type result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model::Type)cc_scene_Model_type_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_type_get) + +static bool js_cc_scene_Model_isDynamicBatching_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_isDynamicBatching_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_isDynamicBatching_set) + +static bool js_cc_scene_Model_isDynamicBatching_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_isDynamicBatching_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_isDynamicBatching_get) + +static bool js_cc_scene_Model_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_priority_set) + +static bool js_cc_scene_Model_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_priority_get) + +static bool js_cc_scene_Model_tetrahedronIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_tetrahedronIndex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_tetrahedronIndex_set) + +static bool js_cc_scene_Model_tetrahedronIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_tetrahedronIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_tetrahedronIndex_get) + +static bool js_cc_scene_Model_useLightProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_useLightProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_useLightProbe_set) + +static bool js_cc_scene_Model_useLightProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_useLightProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_useLightProbe_get) + +static bool js_cc_scene_Model_bakeToReflectionProbe_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_bakeToReflectionProbe_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_bakeToReflectionProbe_set) + +static bool js_cc_scene_Model_bakeToReflectionProbe_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_bakeToReflectionProbe_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_bakeToReflectionProbe_get) + +static bool js_cc_scene_Model_reflectionProbeType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::UseReflectionProbeType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Model_reflectionProbeType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeType_set) + +static bool js_cc_scene_Model_reflectionProbeType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + cc::scene::UseReflectionProbeType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::UseReflectionProbeType)cc_scene_Model_reflectionProbeType_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_scene_Model_reflectionProbeType_get) + +static bool js_cc_scene_Model_receiveDirLight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_receiveDirLight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_receiveDirLight_set) + +static bool js_cc_scene_Model_receiveDirLight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Model_receiveDirLight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_receiveDirLight_get) + +static bool js_cc_scene_Model_reflectionProbeId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_reflectionProbeId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeId_set) + +static bool js_cc_scene_Model_reflectionProbeId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_reflectionProbeId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_reflectionProbeId_get) + +static bool js_cc_scene_Model_reflectionProbeBlendId_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_reflectionProbeBlendId_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeBlendId_set) + +static bool js_cc_scene_Model_reflectionProbeBlendId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + int32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Model_reflectionProbeBlendId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_reflectionProbeBlendId_get) + +static bool js_cc_scene_Model_reflectionProbeBlendWeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Model_reflectionProbeBlendWeight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Model_reflectionProbeBlendWeight_set) + +static bool js_cc_scene_Model_reflectionProbeBlendWeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Model *arg1 = (cc::scene::Model *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Model_reflectionProbeBlendWeight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Model_reflectionProbeBlendWeight_get) + +bool js_register_cc_scene_Model(se::Object* obj) { + auto* cls = se::Class::create("Model", obj, nullptr, _SE(js_new_cc_scene_Model)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("scene", _SE(js_cc_scene_Model_scene_get), _SE(js_cc_scene_Model_scene_set)); + cls->defineProperty("_subModels", _SE(js_cc_scene_Model__subModels_get), nullptr); + cls->defineProperty("subModels", _SE(js_cc_scene_Model_subModels_get), nullptr); + cls->defineProperty("inited", _SE(js_cc_scene_Model_inited_get), nullptr); + cls->defineProperty("_localDataUpdated", _SE(js_cc_scene_Model__localDataUpdated_get), _SE(js_cc_scene_Model__localDataUpdated_set)); + cls->defineProperty("_worldBounds", _SE(js_cc_scene_Model__worldBounds_get), _SE(js_cc_scene_Model__worldBounds_set)); + cls->defineProperty("worldBounds", _SE(js_cc_scene_Model_worldBounds_get), _SE(js_cc_scene_Model_worldBounds_set)); + cls->defineProperty("_modelBounds", _SE(js_cc_scene_Model__modelBounds_get), _SE(js_cc_scene_Model__modelBounds_set)); + cls->defineProperty("modelBounds", _SE(js_cc_scene_Model_modelBounds_get), _SE(js_cc_scene_Model_modelBounds_set)); + cls->defineProperty("worldBoundBuffer", _SE(js_cc_scene_Model_worldBoundBuffer_get), _SE(js_cc_scene_Model_worldBoundBuffer_set)); + cls->defineProperty("localBuffer", _SE(js_cc_scene_Model_localBuffer_get), _SE(js_cc_scene_Model_localBuffer_set)); + cls->defineProperty("updateStamp", _SE(js_cc_scene_Model_updateStamp_get), nullptr); + cls->defineProperty("receiveShadow", _SE(js_cc_scene_Model_receiveShadow_get), _SE(js_cc_scene_Model_receiveShadow_set)); + cls->defineProperty("castShadow", _SE(js_cc_scene_Model_castShadow_get), _SE(js_cc_scene_Model_castShadow_set)); + cls->defineProperty("shadowBias", _SE(js_cc_scene_Model_shadowBias_get), _SE(js_cc_scene_Model_shadowBias_set)); + cls->defineProperty("shadowNormalBias", _SE(js_cc_scene_Model_shadowNormalBias_get), _SE(js_cc_scene_Model_shadowNormalBias_set)); + cls->defineProperty("node", _SE(js_cc_scene_Model_node_get), _SE(js_cc_scene_Model_node_set)); + cls->defineProperty("transform", _SE(js_cc_scene_Model_transform_get), _SE(js_cc_scene_Model_transform_set)); + cls->defineProperty("visFlags", _SE(js_cc_scene_Model_visFlags_get), _SE(js_cc_scene_Model_visFlags_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_Model_enabled_get), _SE(js_cc_scene_Model_enabled_set)); + cls->defineProperty("type", _SE(js_cc_scene_Model_type_get), _SE(js_cc_scene_Model_type_set)); + cls->defineProperty("isDynamicBatching", _SE(js_cc_scene_Model_isDynamicBatching_get), _SE(js_cc_scene_Model_isDynamicBatching_set)); + cls->defineProperty("priority", _SE(js_cc_scene_Model_priority_get), _SE(js_cc_scene_Model_priority_set)); + cls->defineProperty("tetrahedronIndex", _SE(js_cc_scene_Model_tetrahedronIndex_get), _SE(js_cc_scene_Model_tetrahedronIndex_set)); + cls->defineProperty("useLightProbe", _SE(js_cc_scene_Model_useLightProbe_get), _SE(js_cc_scene_Model_useLightProbe_set)); + cls->defineProperty("bakeToReflectionProbe", _SE(js_cc_scene_Model_bakeToReflectionProbe_get), _SE(js_cc_scene_Model_bakeToReflectionProbe_set)); + cls->defineProperty("reflectionProbeType", _SE(js_cc_scene_Model_reflectionProbeType_get), _SE(js_cc_scene_Model_reflectionProbeType_set)); + cls->defineProperty("receiveDirLight", _SE(js_cc_scene_Model_receiveDirLight_get), _SE(js_cc_scene_Model_receiveDirLight_set)); + cls->defineProperty("reflectionProbeId", _SE(js_cc_scene_Model_reflectionProbeId_get), _SE(js_cc_scene_Model_reflectionProbeId_set)); + cls->defineProperty("reflectionProbeBlendId", _SE(js_cc_scene_Model_reflectionProbeBlendId_get), _SE(js_cc_scene_Model_reflectionProbeBlendId_set)); + cls->defineProperty("reflectionProbeBlendWeight", _SE(js_cc_scene_Model_reflectionProbeBlendWeight_get), _SE(js_cc_scene_Model_reflectionProbeBlendWeight_set)); + + cls->defineFunction("destroy", _SE(js_cc_scene_Model_destroy)); + cls->defineFunction("initSubModel", _SE(js_cc_scene_Model_initSubModel)); + cls->defineFunction("getMacroPatches", _SE(js_cc_scene_Model_getMacroPatches)); + cls->defineFunction("setSubModelMaterial", _SE(js_cc_scene_Model_setSubModelMaterial)); + cls->defineFunction("_updateInstancedAttributes", _SE(js_cc_scene_Model__updateInstancedAttributes)); + cls->defineFunction("updateTransform", _SE(js_cc_scene_Model_updateTransform)); + cls->defineFunction("updateUBOs", _SE(js_cc_scene_Model_updateUBOs)); + cls->defineFunction("_updateLocalDescriptors", _SE(js_cc_scene_Model__updateLocalDescriptors)); + cls->defineFunction("_updateLocalSHDescriptors", _SE(js_cc_scene_Model__updateLocalSHDescriptors)); + cls->defineFunction("_updateWorldBoundDescriptors", _SE(js_cc_scene_Model__updateWorldBoundDescriptors)); + cls->defineFunction("createBoundingShape", _SE(js_cc_scene_Model_createBoundingShape)); + cls->defineFunction("initialize", _SE(js_cc_scene_Model_initialize)); + cls->defineFunction("initLightingmap", _SE(js_cc_scene_Model_initLightingmap)); + cls->defineFunction("_initLocalDescriptors", _SE(js_cc_scene_Model__initLocalDescriptors)); + cls->defineFunction("_initLocalSHDescriptors", _SE(js_cc_scene_Model__initLocalSHDescriptors)); + cls->defineFunction("initWorldBoundDescriptors", _SE(js_cc_scene_Model_initWorldBoundDescriptors)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_scene_Model_onGlobalPipelineStateChanged)); + cls->defineFunction("onMacroPatchesStateChanged", _SE(js_cc_scene_Model_onMacroPatchesStateChanged)); + cls->defineFunction("onGeometryChanged", _SE(js_cc_scene_Model_onGeometryChanged)); + cls->defineFunction("setSubModelMesh", _SE(js_cc_scene_Model_setSubModelMesh)); + cls->defineFunction("setInstancedAttribute", _SE(js_cc_scene_Model_setInstancedAttribute)); + cls->defineFunction("updateWorldBound", _SE(js_cc_scene_Model_updateWorldBound)); + cls->defineFunction("updateWorldBoundsForJSSkinningModel", _SE(js_cc_scene_Model_updateWorldBoundsForJSSkinningModel)); + cls->defineFunction("updateWorldBoundsForJSBakedSkinningModel", _SE(js_cc_scene_Model_updateWorldBoundsForJSBakedSkinningModel)); + cls->defineFunction("updateLightingmap", _SE(js_cc_scene_Model_updateLightingmap)); + cls->defineFunction("clearSHUBOs", _SE(js_cc_scene_Model_clearSHUBOs)); + cls->defineFunction("updateSHUBOs", _SE(js_cc_scene_Model_updateSHUBOs)); + cls->defineFunction("updateWorldBoundUBOs", _SE(js_cc_scene_Model_updateWorldBoundUBOs)); + cls->defineFunction("updateLocalShadowBias", _SE(js_cc_scene_Model_updateLocalShadowBias)); + cls->defineFunction("updateReflectionProbeCubemap", _SE(js_cc_scene_Model_updateReflectionProbeCubemap)); + cls->defineFunction("updateReflectionProbePlanarMap", _SE(js_cc_scene_Model_updateReflectionProbePlanarMap)); + cls->defineFunction("updateReflectionProbeId", _SE(js_cc_scene_Model_updateReflectionProbeId)); + cls->defineFunction("updateReflectionProbeDataMap", _SE(js_cc_scene_Model_updateReflectionProbeDataMap)); + cls->defineFunction("updateReflectionProbeBlendCubemap", _SE(js_cc_scene_Model_updateReflectionProbeBlendCubemap)); + cls->defineFunction("attachToScene", _SE(js_cc_scene_Model_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_Model_detachFromScene)); + cls->defineFunction("setLocalSHBuffer", _SE(js_cc_scene_Model_setLocalSHBuffer)); + cls->defineFunction("setBounds", _SE(js_cc_scene_Model_setBounds)); + cls->defineFunction("showTetrahedron", _SE(js_cc_scene_Model_showTetrahedron)); + cls->defineFunction("getLocalSHBuffer", _SE(js_cc_scene_Model_getLocalSHBuffer)); + cls->defineFunction("getLocalSHData", _SE(js_cc_scene_Model_getLocalSHData)); + cls->defineFunction("invalidateLocalData", _SE(js_cc_scene_Model_invalidateLocalData)); + cls->defineFunction("setCalledFromJS", _SE(js_cc_scene_Model_setCalledFromJS)); + cls->defineFunction("isModelImplementedInJS", _SE(js_cc_scene_Model_isModelImplementedInJS)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Model)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Model_proto = cls->getProto(); + __jsb_cc_scene_Model_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_InstancedAttributeBlock_class = nullptr; +se::Object* __jsb_cc_scene_InstancedAttributeBlock_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_InstancedAttributeBlock) + +static bool js_cc_scene_IInstancedAttributeBlock_buffer_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->buffer, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IInstancedAttributeBlock_buffer_set) + +static bool js_cc_scene_IInstancedAttributeBlock_buffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->buffer, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->buffer, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IInstancedAttributeBlock_buffer_get) + +static bool js_cc_scene_IInstancedAttributeBlock_views_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->views, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IInstancedAttributeBlock_views_set) + +static bool js_cc_scene_IInstancedAttributeBlock_views_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->views, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->views, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IInstancedAttributeBlock_views_get) + +static bool js_cc_scene_IInstancedAttributeBlock_attributes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->attributes, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IInstancedAttributeBlock_attributes_set) + +static bool js_cc_scene_IInstancedAttributeBlock_attributes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::InstancedAttributeBlock *arg1 = (cc::scene::InstancedAttributeBlock *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->attributes, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->attributes, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IInstancedAttributeBlock_attributes_get) + +static bool js_new_cc_scene_InstancedAttributeBlock(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::InstancedAttributeBlock *result; + result = (cc::scene::InstancedAttributeBlock *)new cc::scene::InstancedAttributeBlock(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_InstancedAttributeBlock, __jsb_cc_scene_InstancedAttributeBlock_class, js_delete_cc_scene_InstancedAttributeBlock) + +static bool js_delete_cc_scene_InstancedAttributeBlock(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_InstancedAttributeBlock) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::InstancedAttributeBlock * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("buffer", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->buffer), ctx); + } + + + json->getProperty("views", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->views), ctx); + } + + + json->getProperty("attributes", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->attributes), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_InstancedAttributeBlock(se::Object* obj) { + auto* cls = se::Class::create("IInstancedAttributeBlock", obj, nullptr, _SE(js_new_cc_scene_InstancedAttributeBlock)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("buffer", _SE(js_cc_scene_IInstancedAttributeBlock_buffer_get), _SE(js_cc_scene_IInstancedAttributeBlock_buffer_set)); + cls->defineProperty("views", _SE(js_cc_scene_IInstancedAttributeBlock_views_get), _SE(js_cc_scene_IInstancedAttributeBlock_views_set)); + cls->defineProperty("attributes", _SE(js_cc_scene_IInstancedAttributeBlock_attributes_get), _SE(js_cc_scene_IInstancedAttributeBlock_attributes_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_InstancedAttributeBlock)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_InstancedAttributeBlock_proto = cls->getProto(); + __jsb_cc_scene_InstancedAttributeBlock_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_SubModel_class = nullptr; +se::Object* __jsb_cc_scene_SubModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_SubModel) + +static bool js_new_cc_scene_SubModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::SubModel *result; + result = (cc::scene::SubModel *)new cc::scene::SubModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_SubModel, __jsb_cc_scene_SubModel_class, js_delete_cc_scene_SubModel) + +static bool js_delete_cc_scene_SubModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_SubModel) + +static bool js_cc_scene_SubModel_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_update) + +static bool js_cc_scene_SubModel_getShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + uint32_t arg2 ; + cc::gfx::Shader *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::gfx::Shader *)((cc::scene::SubModel const *)arg1)->getShader(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_scene_SubModel_getShader) + +static bool js_cc_scene_SubModel_getPass(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + uint32_t arg2 ; + cc::scene::Pass *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (cc::scene::Pass *)((cc::scene::SubModel const *)arg1)->getPass(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_scene_SubModel_getPass) + +static bool js_cc_scene_SubModel_setWorldBoundDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setWorldBoundDescriptorSet(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setWorldBoundDescriptorSet) + +static bool js_cc_scene_SubModel_setOwner(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOwner(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setOwner) + +static bool js_cc_scene_SubModel_setInstancedAttribute(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::string *arg2 = 0 ; + cc::TypedArray *arg3 = 0 ; + ccstd::string temp2 ; + cc::TypedArray temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setInstancedAttribute((ccstd::string const &)*arg2,(cc::TypedArray const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setInstancedAttribute) + +static bool js_cc_scene_SubModel_getWorldBoundDescriptorSet(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *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(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)((cc::scene::SubModel const *)arg1)->getWorldBoundDescriptorSet(); + + 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_scene_SubModel_getWorldBoundDescriptorSet) + +static bool js_cc_scene_SubModel_getOwner(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::Model *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Model *)((cc::scene::SubModel const *)arg1)->getOwner(); + + 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_scene_SubModel_getOwner) + +static bool js_cc_scene_SubModel_getId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::SubModel const *)arg1)->getId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_getId) + +static bool js_cc_scene_SubModel_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::RenderingSubMesh *arg2 = (cc::RenderingSubMesh *) NULL ; + cc::scene::SharedPassArray *arg3 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > *arg4 = 0 ; + cc::scene::SharedPassArray temp3 ; + ccstd::vector< cc::scene::IMacroPatch > temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->initialize(arg2,(cc::scene::SharedPassArray const &)*arg3,(ccstd::vector< cc::scene::IMacroPatch > const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_initialize) + +static bool js_cc_scene_SubModel_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_destroy) + +static bool js_cc_scene_SubModel_onPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_onPipelineStateChanged) + +static bool js_cc_scene_SubModel_onMacroPatchesStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->onMacroPatchesStateChanged((ccstd::vector< cc::scene::IMacroPatch > const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_onMacroPatchesStateChanged) + +static bool js_cc_scene_SubModel_onGeometryChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGeometryChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_onGeometryChanged) + +static bool js_cc_scene_SubModel_getReflectionProbeType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + int32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::SubModel const *)arg1)->getReflectionProbeType(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_getReflectionProbeType) + +static bool js_cc_scene_SubModel_setReflectionProbeType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + int32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setReflectionProbeType(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_SubModel_setReflectionProbeType) + +static bool js_cc_scene_SubModel_passes_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::SharedPassArray *arg2 = 0 ; + cc::scene::SharedPassArray temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SubModel_passes_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_passes_set) + +static bool js_cc_scene_SubModel_passes_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::scene::SharedPassArray *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::SharedPassArray *) &cc_scene_SubModel_passes_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_scene_SubModel_passes_get) + +static bool js_cc_scene_SubModel_shaders_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > *arg2 = 0 ; + ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_SubModel_shaders_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_shaders_set) + +static bool js_cc_scene_SubModel_shaders_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::gfx::Shader > > *) &cc_scene_SubModel_shaders_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_scene_SubModel_shaders_get) + +static bool js_cc_scene_SubModel_subMesh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::RenderingSubMesh *arg2 = (cc::RenderingSubMesh *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SubModel_subMesh_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_subMesh_set) + +static bool js_cc_scene_SubModel_subMesh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::RenderingSubMesh *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::RenderingSubMesh *)cc_scene_SubModel_subMesh_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_scene_SubModel_subMesh_get) + +static bool js_cc_scene_SubModel_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::pipeline::RenderPriority arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_SubModel_priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_priority_set) + +static bool js_cc_scene_SubModel_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::pipeline::RenderPriority result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_SubModel_priority_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_scene_SubModel_priority_get) + +static bool js_cc_scene_SubModel_inputAssembler_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::InputAssembler *arg2 = (cc::gfx::InputAssembler *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SubModel_inputAssembler_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_inputAssembler_set) + +static bool js_cc_scene_SubModel_inputAssembler_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::InputAssembler *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::InputAssembler *)cc_scene_SubModel_inputAssembler_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_scene_SubModel_inputAssembler_get) + +static bool js_cc_scene_SubModel_descriptorSet_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *arg2 = (cc::gfx::DescriptorSet *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_SubModel_descriptorSet_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_SubModel_descriptorSet_set) + +static bool js_cc_scene_SubModel_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + cc::gfx::DescriptorSet *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)cc_scene_SubModel_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_scene_SubModel_descriptorSet_get) + +static bool js_cc_scene_SubModel_patches_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::SubModel *arg1 = (cc::scene::SubModel *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::scene::IMacroPatch > *) &cc_scene_SubModel_patches_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_scene_SubModel_patches_get) + +bool js_register_cc_scene_SubModel(se::Object* obj) { + auto* cls = se::Class::create("SubModel", obj, nullptr, _SE(js_new_cc_scene_SubModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("passes", _SE(js_cc_scene_SubModel_passes_get), _SE(js_cc_scene_SubModel_passes_set)); + cls->defineProperty("shaders", _SE(js_cc_scene_SubModel_shaders_get), _SE(js_cc_scene_SubModel_shaders_set)); + cls->defineProperty("subMesh", _SE(js_cc_scene_SubModel_subMesh_get), _SE(js_cc_scene_SubModel_subMesh_set)); + cls->defineProperty("priority", _SE(js_cc_scene_SubModel_priority_get), _SE(js_cc_scene_SubModel_priority_set)); + cls->defineProperty("inputAssembler", _SE(js_cc_scene_SubModel_inputAssembler_get), _SE(js_cc_scene_SubModel_inputAssembler_set)); + cls->defineProperty("descriptorSet", _SE(js_cc_scene_SubModel_descriptorSet_get), _SE(js_cc_scene_SubModel_descriptorSet_set)); + cls->defineProperty("patches", _SE(js_cc_scene_SubModel_patches_get), nullptr); + + cls->defineFunction("update", _SE(js_cc_scene_SubModel_update)); + cls->defineFunction("getShader", _SE(js_cc_scene_SubModel_getShader)); + cls->defineFunction("getPass", _SE(js_cc_scene_SubModel_getPass)); + cls->defineFunction("setWorldBoundDescriptorSet", _SE(js_cc_scene_SubModel_setWorldBoundDescriptorSet)); + cls->defineFunction("setOwner", _SE(js_cc_scene_SubModel_setOwner)); + cls->defineFunction("setInstancedAttribute", _SE(js_cc_scene_SubModel_setInstancedAttribute)); + cls->defineFunction("getWorldBoundDescriptorSet", _SE(js_cc_scene_SubModel_getWorldBoundDescriptorSet)); + cls->defineFunction("getOwner", _SE(js_cc_scene_SubModel_getOwner)); + cls->defineFunction("getId", _SE(js_cc_scene_SubModel_getId)); + cls->defineFunction("initialize", _SE(js_cc_scene_SubModel_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_SubModel_destroy)); + cls->defineFunction("onPipelineStateChanged", _SE(js_cc_scene_SubModel_onPipelineStateChanged)); + cls->defineFunction("onMacroPatchesStateChanged", _SE(js_cc_scene_SubModel_onMacroPatchesStateChanged)); + cls->defineFunction("onGeometryChanged", _SE(js_cc_scene_SubModel_onGeometryChanged)); + cls->defineFunction("getReflectionProbeType", _SE(js_cc_scene_SubModel_getReflectionProbeType)); + cls->defineFunction("setReflectionProbeType", _SE(js_cc_scene_SubModel_setReflectionProbeType)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_SubModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_SubModel_proto = cls->getProto(); + __jsb_cc_scene_SubModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_PassDynamicsValue_class = nullptr; +se::Object* __jsb_cc_scene_PassDynamicsValue_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_PassDynamicsValue) + +static bool js_cc_scene_PassDynamicsValue_dirty_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->dirty); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PassDynamicsValue_dirty_set) + +static bool js_cc_scene_PassDynamicsValue_dirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->dirty, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PassDynamicsValue_dirty_get) + +static bool js_cc_scene_PassDynamicsValue_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_PassDynamicsValue_value_set) + +static bool js_cc_scene_PassDynamicsValue_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::PassDynamicsValue *arg1 = (cc::scene::PassDynamicsValue *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_PassDynamicsValue_value_get) + +static bool js_new_cc_scene_PassDynamicsValue(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::PassDynamicsValue *result; + result = (cc::scene::PassDynamicsValue *)new cc::scene::PassDynamicsValue(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_PassDynamicsValue, __jsb_cc_scene_PassDynamicsValue_class, js_delete_cc_scene_PassDynamicsValue) + +static bool js_delete_cc_scene_PassDynamicsValue(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_PassDynamicsValue) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::PassDynamicsValue * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("dirty", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->dirty), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_PassDynamicsValue(se::Object* obj) { + auto* cls = se::Class::create("PassDynamicsValue", obj, nullptr, _SE(js_new_cc_scene_PassDynamicsValue)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("dirty", _SE(js_cc_scene_PassDynamicsValue_dirty_get), _SE(js_cc_scene_PassDynamicsValue_dirty_set)); + cls->defineProperty("value", _SE(js_cc_scene_PassDynamicsValue_value_get), _SE(js_cc_scene_PassDynamicsValue_value_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_PassDynamicsValue)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_PassDynamicsValue_proto = cls->getProto(); + __jsb_cc_scene_PassDynamicsValue_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IBlockRef_class = nullptr; +se::Object* __jsb_cc_scene_IBlockRef_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IBlockRef) + +static bool js_cc_scene_IBlockRef_data_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->data, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IBlockRef_data_set) + +static bool js_cc_scene_IBlockRef_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->data, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->data, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IBlockRef_data_get) + +static bool js_cc_scene_IBlockRef_count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IBlockRef_count_set) + +static bool js_cc_scene_IBlockRef_count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IBlockRef_count_get) + +static bool js_cc_scene_IBlockRef_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IBlockRef_offset_set) + +static bool js_cc_scene_IBlockRef_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IBlockRef *arg1 = (cc::scene::IBlockRef *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IBlockRef_offset_get) + +static bool js_new_cc_scene_IBlockRef(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IBlockRef *result; + result = (cc::scene::IBlockRef *)new cc::scene::IBlockRef(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IBlockRef, __jsb_cc_scene_IBlockRef_class, js_delete_cc_scene_IBlockRef) + +static bool js_delete_cc_scene_IBlockRef(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IBlockRef) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IBlockRef * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("data", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->data), ctx); + } + + + json->getProperty("count", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->count), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IBlockRef(se::Object* obj) { + auto* cls = se::Class::create("IBlockRef", obj, nullptr, _SE(js_new_cc_scene_IBlockRef)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_cc_scene_IBlockRef_data_get), _SE(js_cc_scene_IBlockRef_data_set)); + cls->defineProperty("count", _SE(js_cc_scene_IBlockRef_count_get), _SE(js_cc_scene_IBlockRef_count_set)); + cls->defineProperty("offset", _SE(js_cc_scene_IBlockRef_offset_get), _SE(js_cc_scene_IBlockRef_offset_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IBlockRef)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IBlockRef_proto = cls->getProto(); + __jsb_cc_scene_IBlockRef_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Pass_class = nullptr; +se::Object* __jsb_cc_scene_Pass_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Pass) + +static bool js_cc_scene_Pass_getTypeFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + cc::gfx::Type result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getTypeFromHandle(SWIG_STD_MOVE(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_FUNC(js_cc_scene_Pass_getTypeFromHandle_static) + +static bool js_cc_scene_Pass_getBindingFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getBindingFromHandle(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getBindingFromHandle_static) + +static bool js_cc_scene_Pass_getCountFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getCountFromHandle(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getCountFromHandle_static) + +static bool js_cc_scene_Pass_getOffsetFromHandle_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint32_t arg1 ; + uint32_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = cc::scene::Pass::getOffsetFromHandle(SWIG_STD_MOVE(arg1)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getOffsetFromHandle_static) + +static bool js_cc_scene_Pass_fillPipelineInfo_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfoFull *arg2 = 0 ; + cc::IPassInfoFull temp2 ; + + 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; + + cc::scene::Pass::fillPipelineInfo(arg1,(cc::IPassInfoFull const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_fillPipelineInfo_static) + +static bool js_cc_scene_Pass_getPassHash_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::hash_t result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::scene::Pass::getPassHash(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_FUNC(js_cc_scene_Pass_getPassHash_static) + +static bool js_new_cc_scene_Pass__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::scene::Pass *result; + result = (cc::scene::Pass *)new cc::scene::Pass(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_Pass__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Root *arg1 = (cc::Root *) NULL ; + cc::scene::Pass *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::Pass *)new cc::scene::Pass(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_Pass(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_scene_Pass__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_scene_Pass__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Pass"); + return false; +} +SE_BIND_CTOR(js_new_cc_scene_Pass, __jsb_cc_scene_Pass_class, js_delete_cc_scene_Pass) + +static bool js_delete_cc_scene_Pass(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Pass) + +static bool js_cc_scene_Pass_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfoFull *arg2 = 0 ; + cc::IPassInfoFull temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::IPassInfoFull const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_initialize) + +static bool js_cc_scene_Pass_getHandle__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + cc::gfx::Type arg4 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::scene::Pass const *)arg1)->getHandle((ccstd::string const &)*arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_getHandle__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(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 = ((cc::scene::Pass const *)arg1)->getHandle((ccstd::string const &)*arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_getHandle__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(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::scene::Pass const *)arg1)->getHandle((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_getHandle(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_Pass_getHandle__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_getHandle__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_Pass_getHandle__SWIG_2(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_getHandle) + +static bool js_cc_scene_Pass_getBinding(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) 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(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::scene::Pass const *)arg1)->getBinding((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getBinding) + +static bool js_cc_scene_Pass_setUniform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::MaterialProperty *arg3 = 0 ; + cc::MaterialProperty temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setUniform(arg2,(cc::MaterialProperty const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setUniform) + +static bool js_cc_scene_Pass__getUniform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::MaterialProperty result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = ((cc::scene::Pass const *)arg1)->getUniform(arg2); + + ccstd::visit( + [&](auto ¶m) { + using ParamType = std::remove_reference_t; + if constexpr (std::is_same_v || std::is_same_v) { + ok = nativevalue_to_se(param, s.rval()); + } else { + auto *temp = ccnew ParamType(param); + ok = nativevalue_to_se(temp, s.rval()); + if (ok) { + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + } else { + s.rval().setUndefined(); + delete temp; + } + } + }, + result); + + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass__getUniform) + +static bool js_cc_scene_Pass_setUniformArray(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::MaterialPropertyList *arg3 = 0 ; + cc::MaterialPropertyList temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setUniformArray(arg2,(cc::MaterialPropertyList const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setUniformArray) + +static bool js_cc_scene_Pass_bindTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_scene_Pass_bindTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Texture *arg3 = (cc::gfx::Texture *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindTexture(arg2,arg3); + + + return true; +} + +static bool js_cc_scene_Pass_bindTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_Pass_bindTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_bindTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_bindTexture) + +static bool js_cc_scene_Pass_bindSampler__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + uint32_t arg4 ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_scene_Pass_bindSampler__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t arg2 ; + cc::gfx::Sampler *arg3 = (cc::gfx::Sampler *) NULL ; + + arg1 = SE_THIS_OBJECT(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)->bindSampler(arg2,arg3); + + + return true; +} + +static bool js_cc_scene_Pass_bindSampler(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_scene_Pass_bindSampler__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_bindSampler__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_bindSampler) + +static bool js_cc_scene_Pass_setDynamicState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DynamicStateFlagBit arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDynamicState(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setDynamicState) + +static bool js_cc_scene_Pass_overridePipelineStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfo *arg2 = 0 ; + cc::PassOverrides *arg3 = 0 ; + cc::IPassInfo temp2 ; + cc::PassOverrides temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::IPassInfo const &)*arg2,(cc::PassOverrides const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_overridePipelineStates) + +static bool js_cc_scene_Pass_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_update) + +static bool js_cc_scene_Pass_getInstancedBuffer__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + int32_t arg2 ; + cc::pipeline::InstancedBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::pipeline::InstancedBuffer *)(arg1)->getInstancedBuffer(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_scene_Pass_getInstancedBuffer__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::InstancedBuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::InstancedBuffer *)(arg1)->getInstancedBuffer(); + + 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_scene_Pass_getInstancedBuffer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_Pass_getInstancedBuffer__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_scene_Pass_getInstancedBuffer__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_getInstancedBuffer) + +static bool js_cc_scene_Pass_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_destroy) + +static bool js_cc_scene_Pass_resetUniform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resetUniform((ccstd::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetUniform) + +static bool js_cc_scene_Pass_resetTexture__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->resetTexture((ccstd::string const &)*arg2); + + + return true; +} + +static bool js_cc_scene_Pass_resetTexture__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *arg2 = 0 ; + uint32_t arg3 ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->resetTexture((ccstd::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_scene_Pass_resetTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_Pass_resetTexture__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_scene_Pass_resetTexture__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetTexture) + +static bool js_cc_scene_Pass_resetUBOs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetUBOs(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetUBOs) + +static bool js_cc_scene_Pass_resetTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetTextures(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_resetTextures) + +static bool js_cc_scene_Pass_tryCompile__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->tryCompile(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_tryCompile__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::optional< cc::MacroRecord > *arg2 = 0 ; + ccstd::optional< cc::MacroRecord > temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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)(arg1)->tryCompile((ccstd::optional< cc::MacroRecord > const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_Pass_tryCompile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_scene_Pass_tryCompile__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_Pass_tryCompile__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_tryCompile) + +static bool js_cc_scene_Pass_getShaderVariant__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Shader *)(arg1)->getShaderVariant(); + + 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_scene_Pass_getShaderVariant__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::vector< cc::scene::IMacroPatch > *arg2 = 0 ; + ccstd::vector< cc::scene::IMacroPatch > temp2 ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::Shader *)(arg1)->getShaderVariant((ccstd::vector< cc::scene::IMacroPatch > 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; +} + +static bool js_cc_scene_Pass_getShaderVariant(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 0) { + ok = js_cc_scene_Pass_getShaderVariant__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_Pass_getShaderVariant__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Pass_getShaderVariant) + +static bool js_cc_scene_Pass_getPassInfoFull(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IPassInfoFull result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Pass const *)arg1)->getPassInfoFull(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getPassInfoFull) + +static bool js_cc_scene_Pass_getRootBlock(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::ArrayBuffer *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(s); + if (nullptr == arg1) return true; + result = (cc::ArrayBuffer *)(arg1)->getRootBlock(); + + 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_scene_Pass_getRootBlock) + +static bool js_cc_scene_Pass_setRootBufferDirty(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRootBufferDirty(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setRootBufferDirty) + +static bool js_cc_scene_Pass_setPriority(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::RenderPriority arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setPriority(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_setPriority) + +static bool js_cc_scene_Pass_getPassID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Pass const *)arg1)->getPassID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getPassID) + +static bool js_cc_scene_Pass_getSubpassOrPassID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Pass const *)arg1)->getSubpassOrPassID(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_getSubpassOrPassID) + +static bool js_cc_scene_Pass__updatePassHash(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updatePassHash(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass__updatePassHash) + +static bool js_cc_scene_Pass_beginChangeStatesSilently(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginChangeStatesSilently(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_beginChangeStatesSilently) + +static bool js_cc_scene_Pass_endChangeStatesSilently(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->endChangeStatesSilently(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Pass_endChangeStatesSilently) + +static bool js_cc_scene_Pass_root_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::Root *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Root *)cc_scene_Pass_root_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_scene_Pass_root_get) + +static bool js_cc_scene_Pass_device_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::Device *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Device *)cc_scene_Pass_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_scene_Pass_device_get) + +static bool js_cc_scene_Pass_shaderInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::IProgramInfo *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::IProgramInfo *)cc_scene_Pass_shaderInfo_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_scene_Pass_shaderInfo_get) + +static bool js_cc_scene_Pass_localSetLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSetLayout *)cc_scene_Pass_localSetLayout_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_scene_Pass_localSetLayout_get) + +static bool js_cc_scene_Pass_program_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_Pass_program_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_scene_Pass_program_get) + +static bool js_cc_scene_Pass_properties_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::PassPropertyInfoMap *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::PassPropertyInfoMap *) &cc_scene_Pass_properties_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_scene_Pass_properties_get) + +static bool js_cc_scene_Pass_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::MacroRecord *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::MacroRecord *) &cc_scene_Pass_defines_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_scene_Pass_defines_get) + +static bool js_cc_scene_Pass_passIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + index_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_passIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_passIndex_get) + +static bool js_cc_scene_Pass_propertyIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + index_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_propertyIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_propertyIndex_get) + +static bool js_cc_scene_Pass_dynamics_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::scene::IPassDynamics *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::IPassDynamics *) &cc_scene_Pass_dynamics_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_scene_Pass_dynamics_get) + +static bool js_cc_scene_Pass_rootBufferDirty_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Pass_rootBufferDirty_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_rootBufferDirty_get) + +static bool js_cc_scene_Pass_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::RenderPriority result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_priority_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_scene_Pass_priority_get) + +static bool js_cc_scene_Pass_primitive_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::PrimitiveMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_primitive_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_scene_Pass_primitive_get) + +static bool js_cc_scene_Pass_stage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::pipeline::RenderPassStage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_stage_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_scene_Pass_stage_get) + +static bool js_cc_scene_Pass_phase_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_phase_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_phase_get) + +static bool js_cc_scene_Pass_phaseID_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_phaseID_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Pass_phaseID_get) + +static bool js_cc_scene_Pass_rasterizerState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::RasterizerState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::RasterizerState *)cc_scene_Pass_rasterizerState_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_scene_Pass_rasterizerState_get) + +static bool js_cc_scene_Pass_depthStencilState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DepthStencilState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DepthStencilState *)cc_scene_Pass_depthStencilState_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_scene_Pass_depthStencilState_get) + +static bool js_cc_scene_Pass_blendState_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::BlendState *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::BlendState *)cc_scene_Pass_blendState_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_scene_Pass_blendState_get) + +static bool js_cc_scene_Pass_dynamicStates_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DynamicStateFlagBit result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_dynamicStates_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_scene_Pass_dynamicStates_get) + +static bool js_cc_scene_Pass_batchingScheme_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::scene::BatchingSchemes result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::BatchingSchemes)cc_scene_Pass_batchingScheme_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_scene_Pass_batchingScheme_get) + +static bool js_cc_scene_Pass_descriptorSet_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::DescriptorSet *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::DescriptorSet *)cc_scene_Pass_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_scene_Pass_descriptorSet_get) + +static bool js_cc_scene_Pass_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + ccstd::hash_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Pass_hash_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_scene_Pass_hash_get) + +static bool js_cc_scene_Pass_pipelineLayout_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::gfx::PipelineLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::PipelineLayout *)cc_scene_Pass_pipelineLayout_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_scene_Pass_pipelineLayout_get) + +bool js_register_cc_scene_Pass(se::Object* obj) { + auto* cls = se::Class::create("Pass", obj, nullptr, _SE(js_new_cc_scene_Pass)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("root", _SE(js_cc_scene_Pass_root_get), nullptr); + cls->defineProperty("device", _SE(js_cc_scene_Pass_device_get), nullptr); + cls->defineProperty("shaderInfo", _SE(js_cc_scene_Pass_shaderInfo_get), nullptr); + cls->defineProperty("localSetLayout", _SE(js_cc_scene_Pass_localSetLayout_get), nullptr); + cls->defineProperty("program", _SE(js_cc_scene_Pass_program_get), nullptr); + cls->defineProperty("properties", _SE(js_cc_scene_Pass_properties_get), nullptr); + cls->defineProperty("defines", _SE(js_cc_scene_Pass_defines_get), nullptr); + cls->defineProperty("passIndex", _SE(js_cc_scene_Pass_passIndex_get), nullptr); + cls->defineProperty("propertyIndex", _SE(js_cc_scene_Pass_propertyIndex_get), nullptr); + cls->defineProperty("dynamics", _SE(js_cc_scene_Pass_dynamics_get), nullptr); + cls->defineProperty("rootBufferDirty", _SE(js_cc_scene_Pass_rootBufferDirty_get), nullptr); + cls->defineProperty("priority", _SE(js_cc_scene_Pass_priority_get), nullptr); + cls->defineProperty("primitive", _SE(js_cc_scene_Pass_primitive_get), nullptr); + cls->defineProperty("stage", _SE(js_cc_scene_Pass_stage_get), nullptr); + cls->defineProperty("phase", _SE(js_cc_scene_Pass_phase_get), nullptr); + cls->defineProperty("phaseID", _SE(js_cc_scene_Pass_phaseID_get), nullptr); + cls->defineProperty("rasterizerState", _SE(js_cc_scene_Pass_rasterizerState_get), nullptr); + cls->defineProperty("depthStencilState", _SE(js_cc_scene_Pass_depthStencilState_get), nullptr); + cls->defineProperty("blendState", _SE(js_cc_scene_Pass_blendState_get), nullptr); + cls->defineProperty("dynamicStates", _SE(js_cc_scene_Pass_dynamicStates_get), nullptr); + cls->defineProperty("batchingScheme", _SE(js_cc_scene_Pass_batchingScheme_get), nullptr); + cls->defineProperty("descriptorSet", _SE(js_cc_scene_Pass_descriptorSet_get), nullptr); + cls->defineProperty("hash", _SE(js_cc_scene_Pass_hash_get), nullptr); + cls->defineProperty("pipelineLayout", _SE(js_cc_scene_Pass_pipelineLayout_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Pass_initialize)); + cls->defineFunction("getHandle", _SE(js_cc_scene_Pass_getHandle)); + cls->defineFunction("getBinding", _SE(js_cc_scene_Pass_getBinding)); + cls->defineFunction("setUniform", _SE(js_cc_scene_Pass_setUniform)); + cls->defineFunction("_getUniform", _SE(js_cc_scene_Pass__getUniform)); + cls->defineFunction("setUniformArray", _SE(js_cc_scene_Pass_setUniformArray)); + cls->defineFunction("bindTexture", _SE(js_cc_scene_Pass_bindTexture)); + cls->defineFunction("bindSampler", _SE(js_cc_scene_Pass_bindSampler)); + cls->defineFunction("setDynamicState", _SE(js_cc_scene_Pass_setDynamicState)); + cls->defineFunction("overridePipelineStates", _SE(js_cc_scene_Pass_overridePipelineStates)); + cls->defineFunction("update", _SE(js_cc_scene_Pass_update)); + cls->defineFunction("getInstancedBuffer", _SE(js_cc_scene_Pass_getInstancedBuffer)); + cls->defineFunction("destroy", _SE(js_cc_scene_Pass_destroy)); + cls->defineFunction("resetUniform", _SE(js_cc_scene_Pass_resetUniform)); + cls->defineFunction("resetTexture", _SE(js_cc_scene_Pass_resetTexture)); + cls->defineFunction("resetUBOs", _SE(js_cc_scene_Pass_resetUBOs)); + cls->defineFunction("resetTextures", _SE(js_cc_scene_Pass_resetTextures)); + cls->defineFunction("tryCompile", _SE(js_cc_scene_Pass_tryCompile)); + cls->defineFunction("getShaderVariant", _SE(js_cc_scene_Pass_getShaderVariant)); + cls->defineFunction("getPassInfoFull", _SE(js_cc_scene_Pass_getPassInfoFull)); + cls->defineFunction("getRootBlock", _SE(js_cc_scene_Pass_getRootBlock)); + cls->defineFunction("setRootBufferDirty", _SE(js_cc_scene_Pass_setRootBufferDirty)); + cls->defineFunction("setPriority", _SE(js_cc_scene_Pass_setPriority)); + cls->defineFunction("getPassID", _SE(js_cc_scene_Pass_getPassID)); + cls->defineFunction("getSubpassOrPassID", _SE(js_cc_scene_Pass_getSubpassOrPassID)); + cls->defineFunction("_updatePassHash", _SE(js_cc_scene_Pass__updatePassHash)); + cls->defineFunction("beginChangeStatesSilently", _SE(js_cc_scene_Pass_beginChangeStatesSilently)); + cls->defineFunction("endChangeStatesSilently", _SE(js_cc_scene_Pass_endChangeStatesSilently)); + + + cls->defineStaticFunction("getTypeFromHandle", _SE(js_cc_scene_Pass_getTypeFromHandle_static)); + cls->defineStaticFunction("getBindingFromHandle", _SE(js_cc_scene_Pass_getBindingFromHandle_static)); + cls->defineStaticFunction("getCountFromHandle", _SE(js_cc_scene_Pass_getCountFromHandle_static)); + cls->defineStaticFunction("getOffsetFromHandle", _SE(js_cc_scene_Pass_getOffsetFromHandle_static)); + cls->defineStaticFunction("fillPipelineInfo", _SE(js_cc_scene_Pass_fillPipelineInfo_static)); + cls->defineStaticFunction("getPassHash", _SE(js_cc_scene_Pass_getPassHash_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Pass)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Pass_proto = cls->getProto(); + __jsb_cc_scene_Pass_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IRaycastResult_class = nullptr; +se::Object* __jsb_cc_scene_IRaycastResult_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IRaycastResult) + +static bool js_cc_scene_IRaycastResult_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->node, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRaycastResult_node_set) + +static bool js_cc_scene_IRaycastResult_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->node, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->node, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRaycastResult_node_get) + +static bool js_cc_scene_IRaycastResult_distance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->distance, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRaycastResult_distance_set) + +static bool js_cc_scene_IRaycastResult_distance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRaycastResult *arg1 = (cc::scene::IRaycastResult *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->distance, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRaycastResult_distance_get) + +static bool js_new_cc_scene_IRaycastResult(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IRaycastResult *result; + result = (cc::scene::IRaycastResult *)new cc::scene::IRaycastResult(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IRaycastResult, __jsb_cc_scene_IRaycastResult_class, js_delete_cc_scene_IRaycastResult) + +static bool js_delete_cc_scene_IRaycastResult(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IRaycastResult) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRaycastResult * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("node", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->node), ctx); + } + + + json->getProperty("distance", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->distance), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IRaycastResult(se::Object* obj) { + auto* cls = se::Class::create("IRaycastResult", obj, nullptr, _SE(js_new_cc_scene_IRaycastResult)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("node", _SE(js_cc_scene_IRaycastResult_node_get), _SE(js_cc_scene_IRaycastResult_node_set)); + cls->defineProperty("distance", _SE(js_cc_scene_IRaycastResult_distance_get), _SE(js_cc_scene_IRaycastResult_distance_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IRaycastResult)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IRaycastResult_proto = cls->getProto(); + __jsb_cc_scene_IRaycastResult_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IRenderSceneInfo_class = nullptr; +se::Object* __jsb_cc_scene_IRenderSceneInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IRenderSceneInfo) + +static bool js_cc_scene_IRenderSceneInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderSceneInfo *arg1 = (cc::scene::IRenderSceneInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderSceneInfo_name_set) + +static bool js_cc_scene_IRenderSceneInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderSceneInfo *arg1 = (cc::scene::IRenderSceneInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderSceneInfo_name_get) + +static bool js_new_cc_scene_IRenderSceneInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IRenderSceneInfo *result; + result = (cc::scene::IRenderSceneInfo *)new cc::scene::IRenderSceneInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IRenderSceneInfo, __jsb_cc_scene_IRenderSceneInfo_class, js_delete_cc_scene_IRenderSceneInfo) + +static bool js_delete_cc_scene_IRenderSceneInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IRenderSceneInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderSceneInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IRenderSceneInfo(se::Object* obj) { + auto* cls = se::Class::create("IRenderSceneInfo", obj, nullptr, _SE(js_new_cc_scene_IRenderSceneInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_IRenderSceneInfo_name_get), _SE(js_cc_scene_IRenderSceneInfo_name_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IRenderSceneInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IRenderSceneInfo_proto = cls->getProto(); + __jsb_cc_scene_IRenderSceneInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_RenderScene_class = nullptr; +se::Object* __jsb_cc_scene_RenderScene_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_RenderScene) + +static bool js_new_cc_scene_RenderScene(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::RenderScene *result; + result = (cc::scene::RenderScene *)new cc::scene::RenderScene(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_RenderScene, __jsb_cc_scene_RenderScene_class, js_delete_cc_scene_RenderScene) + +static bool js_delete_cc_scene_RenderScene(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_RenderScene) + +static bool js_cc_scene_RenderScene_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::IRenderSceneInfo *arg2 = 0 ; + cc::scene::IRenderSceneInfo 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(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)(arg1)->initialize((cc::scene::IRenderSceneInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_initialize) + +static bool js_cc_scene_RenderScene_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_update) + +static bool js_cc_scene_RenderScene_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_destroy) + +static bool js_cc_scene_RenderScene_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->activate(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_activate) + +static bool js_cc_scene_RenderScene_addCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addCamera) + +static bool js_cc_scene_RenderScene_removeCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeCamera) + +static bool js_cc_scene_RenderScene_removeCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeCameras(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeCameras) + +static bool js_cc_scene_RenderScene_addLODGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::LODGroup *arg2 = (cc::scene::LODGroup *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addLODGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addLODGroup) + +static bool js_cc_scene_RenderScene_removeLODGroup(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::LODGroup *arg2 = (cc::scene::LODGroup *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeLODGroup(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeLODGroup) + +static bool js_cc_scene_RenderScene_isCulledByLod(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::scene::Model *arg3 = (cc::scene::Model *) NULL ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)((cc::scene::RenderScene const *)arg1)->isCulledByLod((cc::scene::Camera const *)arg2,(cc::scene::Model const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_isCulledByLod) + +static bool js_cc_scene_RenderScene_unsetMainLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->unsetMainLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_unsetMainLight) + +static bool js_cc_scene_RenderScene_addDirectionalLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addDirectionalLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addDirectionalLight) + +static bool js_cc_scene_RenderScene_removeDirectionalLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeDirectionalLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeDirectionalLight) + +static bool js_cc_scene_RenderScene_addSphereLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSphereLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addSphereLight) + +static bool js_cc_scene_RenderScene_removeSphereLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SphereLight *arg2 = (cc::scene::SphereLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeSphereLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSphereLight) + +static bool js_cc_scene_RenderScene_removeSphereLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeSphereLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSphereLights) + +static bool js_cc_scene_RenderScene_addSpotLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSpotLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addSpotLight) + +static bool js_cc_scene_RenderScene_removeSpotLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::SpotLight *arg2 = (cc::scene::SpotLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeSpotLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSpotLight) + +static bool js_cc_scene_RenderScene_removeSpotLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeSpotLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeSpotLights) + +static bool js_cc_scene_RenderScene_addPointLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addPointLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addPointLight) + +static bool js_cc_scene_RenderScene_removePointLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::PointLight *arg2 = (cc::scene::PointLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removePointLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removePointLight) + +static bool js_cc_scene_RenderScene_removePointLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removePointLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removePointLights) + +static bool js_cc_scene_RenderScene_addRangedDirLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addRangedDirLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addRangedDirLight) + +static bool js_cc_scene_RenderScene_removeRangedDirLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::RangedDirectionalLight *arg2 = (cc::scene::RangedDirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeRangedDirLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeRangedDirLight) + +static bool js_cc_scene_RenderScene_removeRangedDirLights(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeRangedDirLights(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeRangedDirLights) + +static bool js_cc_scene_RenderScene_addModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_addModel) + +static bool js_cc_scene_RenderScene_removeModel(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->removeModel(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeModel) + +static bool js_cc_scene_RenderScene_removeModels(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->removeModels(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_removeModels) + +static bool js_cc_scene_RenderScene_onGlobalPipelineStateChanged(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onGlobalPipelineStateChanged(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_onGlobalPipelineStateChanged) + +static bool js_cc_scene_RenderScene_getMainLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::DirectionalLight *)((cc::scene::RenderScene const *)arg1)->getMainLight(); + + 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_scene_RenderScene_getMainLight) + +static bool js_cc_scene_RenderScene_setMainLight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::DirectionalLight *arg2 = (cc::scene::DirectionalLight *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMainLight(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_setMainLight) + +static bool js_cc_scene_RenderScene_generateModelId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + uint64_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->generateModelId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_generateModelId) + +static bool js_cc_scene_RenderScene_getOctree(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Octree *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(s); + if (nullptr == arg1) return true; + result = (cc::scene::Octree *)((cc::scene::RenderScene const *)arg1)->getOctree(); + + 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_scene_RenderScene_getOctree) + +static bool js_cc_scene_RenderScene_updateOctree(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateOctree(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderScene_updateOctree) + +static bool js_cc_scene_RenderScene_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_RenderScene_name_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_scene_RenderScene_name_get) + +static bool js_cc_scene_RenderScene_cameras_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *) &cc_scene_RenderScene_cameras_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_scene_RenderScene_cameras_get) + +static bool js_cc_scene_RenderScene_sphereLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SphereLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SphereLight > > *) &cc_scene_RenderScene_sphereLights_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_scene_RenderScene_sphereLights_get) + +static bool js_cc_scene_RenderScene_spotLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::SpotLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::SpotLight > > *) &cc_scene_RenderScene_spotLights_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_scene_RenderScene_spotLights_get) + +static bool js_cc_scene_RenderScene_pointLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::PointLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::PointLight > > *) &cc_scene_RenderScene_pointLights_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_scene_RenderScene_pointLights_get) + +static bool js_cc_scene_RenderScene_rangedDirLights_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::RangedDirectionalLight > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::RangedDirectionalLight > > *) &cc_scene_RenderScene_rangedDirLights_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_scene_RenderScene_rangedDirLights_get) + +static bool js_cc_scene_RenderScene_models_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Model > > *) &cc_scene_RenderScene_models_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_scene_RenderScene_models_get) + +static bool js_cc_scene_RenderScene_lodGroups_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderScene *arg1 = (cc::scene::RenderScene *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::LODGroup > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::LODGroup > > *) &cc_scene_RenderScene_lodGroups_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_scene_RenderScene_lodGroups_get) + +bool js_register_cc_scene_RenderScene(se::Object* obj) { + auto* cls = se::Class::create("RenderScene", obj, nullptr, _SE(js_new_cc_scene_RenderScene)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_RenderScene_name_get), nullptr); + cls->defineProperty("cameras", _SE(js_cc_scene_RenderScene_cameras_get), nullptr); + cls->defineProperty("sphereLights", _SE(js_cc_scene_RenderScene_sphereLights_get), nullptr); + cls->defineProperty("spotLights", _SE(js_cc_scene_RenderScene_spotLights_get), nullptr); + cls->defineProperty("pointLights", _SE(js_cc_scene_RenderScene_pointLights_get), nullptr); + cls->defineProperty("rangedDirLights", _SE(js_cc_scene_RenderScene_rangedDirLights_get), nullptr); + cls->defineProperty("models", _SE(js_cc_scene_RenderScene_models_get), nullptr); + cls->defineProperty("lodGroups", _SE(js_cc_scene_RenderScene_lodGroups_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_RenderScene_initialize)); + cls->defineFunction("update", _SE(js_cc_scene_RenderScene_update)); + cls->defineFunction("destroy", _SE(js_cc_scene_RenderScene_destroy)); + cls->defineFunction("activate", _SE(js_cc_scene_RenderScene_activate)); + cls->defineFunction("addCamera", _SE(js_cc_scene_RenderScene_addCamera)); + cls->defineFunction("removeCamera", _SE(js_cc_scene_RenderScene_removeCamera)); + cls->defineFunction("removeCameras", _SE(js_cc_scene_RenderScene_removeCameras)); + cls->defineFunction("addLODGroup", _SE(js_cc_scene_RenderScene_addLODGroup)); + cls->defineFunction("removeLODGroup", _SE(js_cc_scene_RenderScene_removeLODGroup)); + cls->defineFunction("isCulledByLod", _SE(js_cc_scene_RenderScene_isCulledByLod)); + cls->defineFunction("unsetMainLight", _SE(js_cc_scene_RenderScene_unsetMainLight)); + cls->defineFunction("addDirectionalLight", _SE(js_cc_scene_RenderScene_addDirectionalLight)); + cls->defineFunction("removeDirectionalLight", _SE(js_cc_scene_RenderScene_removeDirectionalLight)); + cls->defineFunction("addSphereLight", _SE(js_cc_scene_RenderScene_addSphereLight)); + cls->defineFunction("removeSphereLight", _SE(js_cc_scene_RenderScene_removeSphereLight)); + cls->defineFunction("removeSphereLights", _SE(js_cc_scene_RenderScene_removeSphereLights)); + cls->defineFunction("addSpotLight", _SE(js_cc_scene_RenderScene_addSpotLight)); + cls->defineFunction("removeSpotLight", _SE(js_cc_scene_RenderScene_removeSpotLight)); + cls->defineFunction("removeSpotLights", _SE(js_cc_scene_RenderScene_removeSpotLights)); + cls->defineFunction("addPointLight", _SE(js_cc_scene_RenderScene_addPointLight)); + cls->defineFunction("removePointLight", _SE(js_cc_scene_RenderScene_removePointLight)); + cls->defineFunction("removePointLights", _SE(js_cc_scene_RenderScene_removePointLights)); + cls->defineFunction("addRangedDirLight", _SE(js_cc_scene_RenderScene_addRangedDirLight)); + cls->defineFunction("removeRangedDirLight", _SE(js_cc_scene_RenderScene_removeRangedDirLight)); + cls->defineFunction("removeRangedDirLights", _SE(js_cc_scene_RenderScene_removeRangedDirLights)); + cls->defineFunction("addModel", _SE(js_cc_scene_RenderScene_addModel)); + cls->defineFunction("removeModel", _SE(js_cc_scene_RenderScene_removeModel)); + cls->defineFunction("removeModels", _SE(js_cc_scene_RenderScene_removeModels)); + cls->defineFunction("onGlobalPipelineStateChanged", _SE(js_cc_scene_RenderScene_onGlobalPipelineStateChanged)); + cls->defineFunction("getMainLight", _SE(js_cc_scene_RenderScene_getMainLight)); + cls->defineFunction("setMainLight", _SE(js_cc_scene_RenderScene_setMainLight)); + cls->defineFunction("generateModelId", _SE(js_cc_scene_RenderScene_generateModelId)); + cls->defineFunction("getOctree", _SE(js_cc_scene_RenderScene_getOctree)); + cls->defineFunction("updateOctree", _SE(js_cc_scene_RenderScene_updateOctree)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_RenderScene)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_RenderScene_proto = cls->getProto(); + __jsb_cc_scene_RenderScene_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_IRenderWindowInfo_class = nullptr; +se::Object* __jsb_cc_scene_IRenderWindowInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_IRenderWindowInfo) + +static bool js_cc_scene_IRenderWindowInfo_title_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->title, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_title_set) + +static bool js_cc_scene_IRenderWindowInfo_title_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->title, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->title, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_title_get) + +static bool js_cc_scene_IRenderWindowInfo_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_width_set) + +static bool js_cc_scene_IRenderWindowInfo_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_width_get) + +static bool js_cc_scene_IRenderWindowInfo_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_height_set) + +static bool js_cc_scene_IRenderWindowInfo_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_height_get) + +static bool js_cc_scene_IRenderWindowInfo_renderPassInfo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->renderPassInfo, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_renderPassInfo_set) + +static bool js_cc_scene_IRenderWindowInfo_renderPassInfo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->renderPassInfo, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->renderPassInfo, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_renderPassInfo_get) + +static bool js_cc_scene_IRenderWindowInfo_swapchain_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->swapchain, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_swapchain_set) + +static bool js_cc_scene_IRenderWindowInfo_swapchain_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->swapchain, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->swapchain, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_swapchain_get) + +static bool js_cc_scene_IRenderWindowInfo_externalResLow_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResLow, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_externalResLow_set) + +static bool js_cc_scene_IRenderWindowInfo_externalResLow_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResLow, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResLow, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_externalResLow_get) + +static bool js_cc_scene_IRenderWindowInfo_externalResHigh_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalResHigh, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_externalResHigh_set) + +static bool js_cc_scene_IRenderWindowInfo_externalResHigh_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalResHigh, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalResHigh, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_externalResHigh_get) + +static bool js_cc_scene_IRenderWindowInfo_externalFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->externalFlag, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_IRenderWindowInfo_externalFlag_set) + +static bool js_cc_scene_IRenderWindowInfo_externalFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::IRenderWindowInfo *arg1 = (cc::scene::IRenderWindowInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->externalFlag, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->externalFlag, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_IRenderWindowInfo_externalFlag_get) + +static bool js_new_cc_scene_IRenderWindowInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::IRenderWindowInfo *result; + result = (cc::scene::IRenderWindowInfo *)new cc::scene::IRenderWindowInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_IRenderWindowInfo, __jsb_cc_scene_IRenderWindowInfo_class, js_delete_cc_scene_IRenderWindowInfo) + +static bool js_delete_cc_scene_IRenderWindowInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_IRenderWindowInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderWindowInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("title", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->title), ctx); + } + + + json->getProperty("width", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->width), ctx); + } + + + json->getProperty("height", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->height), ctx); + } + + + json->getProperty("renderPassInfo", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->renderPassInfo), ctx); + } + + + json->getProperty("swapchain", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->swapchain), ctx); + } + + + json->getProperty("externalResLow", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResLow), ctx); + } + + + json->getProperty("externalResHigh", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalResHigh), ctx); + } + + + json->getProperty("externalFlag", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->externalFlag), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_IRenderWindowInfo(se::Object* obj) { + auto* cls = se::Class::create("IRenderWindowInfo", obj, nullptr, _SE(js_new_cc_scene_IRenderWindowInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("title", _SE(js_cc_scene_IRenderWindowInfo_title_get), _SE(js_cc_scene_IRenderWindowInfo_title_set)); + cls->defineProperty("width", _SE(js_cc_scene_IRenderWindowInfo_width_get), _SE(js_cc_scene_IRenderWindowInfo_width_set)); + cls->defineProperty("height", _SE(js_cc_scene_IRenderWindowInfo_height_get), _SE(js_cc_scene_IRenderWindowInfo_height_set)); + cls->defineProperty("renderPassInfo", _SE(js_cc_scene_IRenderWindowInfo_renderPassInfo_get), _SE(js_cc_scene_IRenderWindowInfo_renderPassInfo_set)); + cls->defineProperty("swapchain", _SE(js_cc_scene_IRenderWindowInfo_swapchain_get), _SE(js_cc_scene_IRenderWindowInfo_swapchain_set)); + cls->defineProperty("externalResLow", _SE(js_cc_scene_IRenderWindowInfo_externalResLow_get), _SE(js_cc_scene_IRenderWindowInfo_externalResLow_set)); + cls->defineProperty("externalResHigh", _SE(js_cc_scene_IRenderWindowInfo_externalResHigh_get), _SE(js_cc_scene_IRenderWindowInfo_externalResHigh_set)); + cls->defineProperty("externalFlag", _SE(js_cc_scene_IRenderWindowInfo_externalFlag_get), _SE(js_cc_scene_IRenderWindowInfo_externalFlag_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_IRenderWindowInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_IRenderWindowInfo_proto = cls->getProto(); + __jsb_cc_scene_IRenderWindowInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_RenderWindow_class = nullptr; +se::Object* __jsb_cc_scene_RenderWindow_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_RenderWindow) + +static bool js_new_cc_scene_RenderWindow(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::RenderWindow *result; + result = (cc::scene::RenderWindow *)new cc::scene::RenderWindow(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_RenderWindow, __jsb_cc_scene_RenderWindow_class, js_delete_cc_scene_RenderWindow) + +static bool js_delete_cc_scene_RenderWindow(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_RenderWindow) + +static bool js_cc_scene_RenderWindow_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + cc::scene::IRenderWindowInfo *arg3 = 0 ; + cc::scene::IRenderWindowInfo temp3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->initialize(arg2,*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_initialize) + +static bool js_cc_scene_RenderWindow_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_destroy) + +static bool js_cc_scene_RenderWindow_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_resize) + +static bool js_cc_scene_RenderWindow_extractRenderCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) 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(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)->extractRenderCameras(*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_extractRenderCameras) + +static bool js_cc_scene_RenderWindow_attachCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_attachCamera) + +static bool js_cc_scene_RenderWindow_detachCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->detachCamera(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_detachCamera) + +static bool js_cc_scene_RenderWindow_clearCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearCameras(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_clearCameras) + +static bool js_cc_scene_RenderWindow_sortCameras(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->sortCameras(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_sortCameras) + +static bool js_cc_scene_RenderWindow_isRenderWindowResized(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::RenderWindow const *)arg1)->isRenderWindowResized(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_isRenderWindowResized) + +static bool js_cc_scene_RenderWindow_setRenderWindowResizeHandled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setRenderWindowResizeHandled(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_RenderWindow_setRenderWindowResizeHandled) + +static bool js_cc_scene_RenderWindow_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_RenderWindow_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RenderWindow_width_get) + +static bool js_cc_scene_RenderWindow_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_RenderWindow_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RenderWindow_height_get) + +static bool js_cc_scene_RenderWindow_framebuffer_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::gfx::Framebuffer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Framebuffer *)cc_scene_RenderWindow_framebuffer_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_scene_RenderWindow_framebuffer_get) + +static bool js_cc_scene_RenderWindow_cameras_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::scene::Camera > > *) &cc_scene_RenderWindow_cameras_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_scene_RenderWindow_cameras_get) + +static bool js_cc_scene_RenderWindow_swapchain_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + cc::gfx::Swapchain *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Swapchain *)cc_scene_RenderWindow_swapchain_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_scene_RenderWindow_swapchain_get) + +static bool js_cc_scene_RenderWindow_renderWindowId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_RenderWindow_renderWindowId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_RenderWindow_renderWindowId_get) + +static bool js_cc_scene_RenderWindow_colorName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_RenderWindow_colorName_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_scene_RenderWindow_colorName_get) + +static bool js_cc_scene_RenderWindow_depthStencilName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::RenderWindow *arg1 = (cc::scene::RenderWindow *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_RenderWindow_depthStencilName_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_scene_RenderWindow_depthStencilName_get) + +bool js_register_cc_scene_RenderWindow(se::Object* obj) { + auto* cls = se::Class::create("RenderWindow", obj, nullptr, _SE(js_new_cc_scene_RenderWindow)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("width", _SE(js_cc_scene_RenderWindow_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_scene_RenderWindow_height_get), nullptr); + cls->defineProperty("framebuffer", _SE(js_cc_scene_RenderWindow_framebuffer_get), nullptr); + cls->defineProperty("cameras", _SE(js_cc_scene_RenderWindow_cameras_get), nullptr); + cls->defineProperty("swapchain", _SE(js_cc_scene_RenderWindow_swapchain_get), nullptr); + cls->defineProperty("renderWindowId", _SE(js_cc_scene_RenderWindow_renderWindowId_get), nullptr); + cls->defineProperty("colorName", _SE(js_cc_scene_RenderWindow_colorName_get), nullptr); + cls->defineProperty("depthStencilName", _SE(js_cc_scene_RenderWindow_depthStencilName_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_RenderWindow_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_RenderWindow_destroy)); + cls->defineFunction("resize", _SE(js_cc_scene_RenderWindow_resize)); + cls->defineFunction("extractRenderCameras", _SE(js_cc_scene_RenderWindow_extractRenderCameras)); + cls->defineFunction("attachCamera", _SE(js_cc_scene_RenderWindow_attachCamera)); + cls->defineFunction("detachCamera", _SE(js_cc_scene_RenderWindow_detachCamera)); + cls->defineFunction("clearCameras", _SE(js_cc_scene_RenderWindow_clearCameras)); + cls->defineFunction("sortCameras", _SE(js_cc_scene_RenderWindow_sortCameras)); + cls->defineFunction("isRenderWindowResized", _SE(js_cc_scene_RenderWindow_isRenderWindowResized)); + cls->defineFunction("setRenderWindowResizeHandled", _SE(js_cc_scene_RenderWindow_setRenderWindowResizeHandled)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_RenderWindow)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_RenderWindow_proto = cls->getProto(); + __jsb_cc_scene_RenderWindow_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_ICameraInfo_class = nullptr; +se::Object* __jsb_cc_scene_ICameraInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_ICameraInfo) + +static bool js_cc_scene_ICameraInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_name_set) + +static bool js_cc_scene_ICameraInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_name_get) + +static bool js_cc_scene_ICameraInfo_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->node, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_node_set) + +static bool js_cc_scene_ICameraInfo_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->node, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->node, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_node_get) + +static bool js_cc_scene_ICameraInfo_projection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->projection, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_projection_set) + +static bool js_cc_scene_ICameraInfo_projection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->projection, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->projection, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_projection_get) + +static bool js_cc_scene_ICameraInfo_targetDisplay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->targetDisplay, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_targetDisplay_set) + +static bool js_cc_scene_ICameraInfo_targetDisplay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->targetDisplay, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->targetDisplay, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_targetDisplay_get) + +static bool js_cc_scene_ICameraInfo_window_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->window, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_window_set) + +static bool js_cc_scene_ICameraInfo_window_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->window, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->window, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_window_get) + +static bool js_cc_scene_ICameraInfo_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->priority, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_priority_set) + +static bool js_cc_scene_ICameraInfo_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->priority, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_priority_get) + +static bool js_cc_scene_ICameraInfo_pipeline_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pipeline, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_pipeline_set) + +static bool js_cc_scene_ICameraInfo_pipeline_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pipeline, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pipeline, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_pipeline_get) + +static bool js_cc_scene_ICameraInfo_cameraType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->cameraType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_cameraType_set) + +static bool js_cc_scene_ICameraInfo_cameraType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->cameraType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->cameraType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_cameraType_get) + +static bool js_cc_scene_ICameraInfo_trackingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->trackingType, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_trackingType_set) + +static bool js_cc_scene_ICameraInfo_trackingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->trackingType, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->trackingType, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_trackingType_get) + +static bool js_cc_scene_ICameraInfo_usage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->usage, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ICameraInfo_usage_set) + +static bool js_cc_scene_ICameraInfo_usage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ICameraInfo *arg1 = (cc::scene::ICameraInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->usage, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->usage, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ICameraInfo_usage_get) + +static bool js_new_cc_scene_ICameraInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::ICameraInfo *result; + result = (cc::scene::ICameraInfo *)new cc::scene::ICameraInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_ICameraInfo, __jsb_cc_scene_ICameraInfo_class, js_delete_cc_scene_ICameraInfo) + +static bool js_delete_cc_scene_ICameraInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_ICameraInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::ICameraInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("node", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->node), ctx); + } + + + json->getProperty("projection", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->projection), ctx); + } + + + json->getProperty("targetDisplay", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->targetDisplay), ctx); + } + + + json->getProperty("window", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->window), ctx); + } + + + json->getProperty("priority", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->priority), ctx); + } + + + json->getProperty("pipeline", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->pipeline), ctx); + } + + + json->getProperty("cameraType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->cameraType), ctx); + } + + + json->getProperty("trackingType", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->trackingType), ctx); + } + + + json->getProperty("usage", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->usage), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_ICameraInfo(se::Object* obj) { + auto* cls = se::Class::create("ICameraInfo", obj, nullptr, _SE(js_new_cc_scene_ICameraInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_scene_ICameraInfo_name_get), _SE(js_cc_scene_ICameraInfo_name_set)); + cls->defineProperty("node", _SE(js_cc_scene_ICameraInfo_node_get), _SE(js_cc_scene_ICameraInfo_node_set)); + cls->defineProperty("projection", _SE(js_cc_scene_ICameraInfo_projection_get), _SE(js_cc_scene_ICameraInfo_projection_set)); + cls->defineProperty("targetDisplay", _SE(js_cc_scene_ICameraInfo_targetDisplay_get), _SE(js_cc_scene_ICameraInfo_targetDisplay_set)); + cls->defineProperty("window", _SE(js_cc_scene_ICameraInfo_window_get), _SE(js_cc_scene_ICameraInfo_window_set)); + cls->defineProperty("priority", _SE(js_cc_scene_ICameraInfo_priority_get), _SE(js_cc_scene_ICameraInfo_priority_set)); + cls->defineProperty("pipeline", _SE(js_cc_scene_ICameraInfo_pipeline_get), _SE(js_cc_scene_ICameraInfo_pipeline_set)); + cls->defineProperty("cameraType", _SE(js_cc_scene_ICameraInfo_cameraType_get), _SE(js_cc_scene_ICameraInfo_cameraType_set)); + cls->defineProperty("trackingType", _SE(js_cc_scene_ICameraInfo_trackingType_get), _SE(js_cc_scene_ICameraInfo_trackingType_set)); + cls->defineProperty("usage", _SE(js_cc_scene_ICameraInfo_usage_get), _SE(js_cc_scene_ICameraInfo_usage_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_ICameraInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_ICameraInfo_proto = cls->getProto(); + __jsb_cc_scene_ICameraInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Camera_class = nullptr; +se::Object* __jsb_cc_scene_Camera_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Camera) + +static bool js_new_cc_scene_Camera(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + cc::scene::Camera *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::Camera *)new cc::scene::Camera(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Camera, __jsb_cc_scene_Camera_class, js_delete_cc_scene_Camera) + +static bool js_delete_cc_scene_Camera(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Camera) + +static bool js_cc_scene_Camera_getStandardExposureValue_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::scene::Camera::getStandardExposureValue(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_getStandardExposureValue_static) + +static bool js_cc_scene_Camera_getStandardLightMeterScale_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)cc::scene::Camera::getStandardLightMeterScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_getStandardLightMeterScale_static) + +static bool js_cc_scene_Camera_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::ICameraInfo *arg2 = 0 ; + cc::scene::ICameraInfo 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(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)(arg1)->initialize((cc::scene::ICameraInfo const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_initialize) + +static bool js_cc_scene_Camera_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_destroy) + +static bool js_cc_scene_Camera_attachToScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->attachToScene(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_attachToScene) + +static bool js_cc_scene_Camera_detachFromScene(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachFromScene(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_detachFromScene) + +static bool js_cc_scene_Camera_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->resize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_resize) + +static bool js_cc_scene_Camera_setFixedSize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + uint32_t arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFixedSize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_setFixedSize) + +static bool js_cc_scene_Camera_syncCameraEditor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->syncCameraEditor((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_syncCameraEditor) + +static bool js_cc_scene_Camera_update__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} + +static bool js_cc_scene_Camera_update__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} + +static bool js_cc_scene_Camera_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_Camera_update__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_scene_Camera_update__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_Camera_update) + +static bool js_cc_scene_Camera_changeTargetWindow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->changeTargetWindow(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_changeTargetWindow) + +static bool js_cc_scene_Camera_setViewportInOrientedSpace(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + Rect *arg2 = 0 ; + 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(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)->setViewportInOrientedSpace((Rect const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_setViewportInOrientedSpace) + +static bool js_cc_scene_Camera_initGeometryRenderer(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initGeometryRenderer(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_initGeometryRenderer) + +static bool js_cc_scene_Camera_detachCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->detachCamera(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_detachCamera) + +static bool js_cc_scene_Camera_isCullingEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Camera const *)arg1)->isCullingEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_isCullingEnabled) + +static bool js_cc_scene_Camera_setCullingEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCullingEnable(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_setCullingEnable) + +static bool js_cc_scene_Camera_calculateObliqueMat(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->calculateObliqueMat((cc::Vec4 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_calculateObliqueMat) + +static bool js_cc_scene_Camera_getClipSpaceMinz(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::scene::Camera const *)arg1)->getClipSpaceMinz(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Camera_getClipSpaceMinz) + +static bool js_cc_scene_Camera_iso_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraISO arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_iso_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_iso_set) + +static bool js_cc_scene_Camera_iso_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraISO result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraISO)cc_scene_Camera_iso_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_scene_Camera_iso_get) + +static bool js_cc_scene_Camera_isoValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_isoValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_isoValue_get) + +static bool js_cc_scene_Camera_ec_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_ec_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_ec_set) + +static bool js_cc_scene_Camera_ec_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_ec_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_ec_get) + +static bool js_cc_scene_Camera_exposure_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_exposure_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_exposure_get) + +static bool js_cc_scene_Camera_shutter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraShutter arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_shutter_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_shutter_set) + +static bool js_cc_scene_Camera_shutter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraShutter result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraShutter)cc_scene_Camera_shutter_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_scene_Camera_shutter_get) + +static bool js_cc_scene_Camera_shutterValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_shutterValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_shutterValue_get) + +static bool js_cc_scene_Camera_apertureValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_apertureValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_apertureValue_get) + +static bool js_cc_scene_Camera_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_width_get) + +static bool js_cc_scene_Camera_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_height_get) + +static bool js_cc_scene_Camera_aspect_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_aspect_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_aspect_get) + +static bool js_cc_scene_Camera_scene_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderScene *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderScene *)cc_scene_Camera_scene_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_scene_Camera_scene_get) + +static bool js_cc_scene_Camera_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + ccstd::string *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::string *) &cc_scene_Camera_name_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_scene_Camera_name_get) + +static bool js_cc_scene_Camera_window_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderWindow *arg2 = (cc::scene::RenderWindow *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_window_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_window_set) + +static bool js_cc_scene_Camera_window_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::RenderWindow *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::RenderWindow *)cc_scene_Camera_window_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_scene_Camera_window_get) + +static bool js_cc_scene_Camera_forward_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_forward_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_forward_set) + +static bool js_cc_scene_Camera_forward_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Camera_forward_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_scene_Camera_forward_get) + +static bool js_cc_scene_Camera_aperture_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraAperture arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_aperture_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_aperture_set) + +static bool js_cc_scene_Camera_aperture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraAperture result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraAperture)cc_scene_Camera_aperture_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_scene_Camera_aperture_get) + +static bool js_cc_scene_Camera_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_position_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_position_set) + +static bool js_cc_scene_Camera_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_Camera_position_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_scene_Camera_position_get) + +static bool js_cc_scene_Camera_projectionType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraProjection arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_projectionType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_projectionType_set) + +static bool js_cc_scene_Camera_projectionType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraProjection result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraProjection)cc_scene_Camera_projectionType_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_scene_Camera_projectionType_get) + +static bool js_cc_scene_Camera_fovAxis_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraFOVAxis arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_fovAxis_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_fovAxis_set) + +static bool js_cc_scene_Camera_fovAxis_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraFOVAxis result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraFOVAxis)cc_scene_Camera_fovAxis_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_scene_Camera_fovAxis_get) + +static bool js_cc_scene_Camera_fov_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_fov_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_fov_set) + +static bool js_cc_scene_Camera_fov_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_fov_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_fov_get) + +static bool js_cc_scene_Camera_nearClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_nearClip_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_nearClip_set) + +static bool js_cc_scene_Camera_nearClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_nearClip_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_nearClip_get) + +static bool js_cc_scene_Camera_farClip_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_farClip_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_farClip_set) + +static bool js_cc_scene_Camera_farClip_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_farClip_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_farClip_get) + +static bool js_cc_scene_Camera_viewport_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Rect *arg2 = 0 ; + cc::Rect temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_viewport_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_viewport_set) + +static bool js_cc_scene_Camera_viewport_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Rect *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Rect *) &cc_scene_Camera_viewport_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_scene_Camera_viewport_get) + +static bool js_cc_scene_Camera_orthoHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_orthoHeight_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_orthoHeight_set) + +static bool js_cc_scene_Camera_orthoHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_orthoHeight_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_orthoHeight_get) + +static bool js_cc_scene_Camera_clearColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_clearColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearColor_set) + +static bool js_cc_scene_Camera_clearColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Color *) &cc_scene_Camera_clearColor_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_scene_Camera_clearColor_get) + +static bool js_cc_scene_Camera_clearDepth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_clearDepth_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearDepth_set) + +static bool js_cc_scene_Camera_clearDepth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_clearDepth_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_clearDepth_get) + +static bool js_cc_scene_Camera_clearFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::ClearFlagBit arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_clearFlag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearFlag_set) + +static bool js_cc_scene_Camera_clearFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::ClearFlagBit result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_clearFlag_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_scene_Camera_clearFlag_get) + +static bool js_cc_scene_Camera_clearStencil_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_clearStencil_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_clearStencil_set) + +static bool js_cc_scene_Camera_clearStencil_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_clearStencil_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_clearStencil_get) + +static bool js_cc_scene_Camera_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_enabled_set) + +static bool js_cc_scene_Camera_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Camera_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_enabled_get) + +static bool js_cc_scene_Camera_frustum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::geometry::Frustum *arg2 = 0 ; + cc::geometry::Frustum temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Camera_frustum_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_frustum_set) + +static bool js_cc_scene_Camera_frustum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::geometry::Frustum *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::Frustum *) &cc_scene_Camera_frustum_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_scene_Camera_frustum_get) + +static bool js_cc_scene_Camera_isWindowSize_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_isWindowSize_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_isWindowSize_set) + +static bool js_cc_scene_Camera_isWindowSize_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Camera_isWindowSize_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_isWindowSize_get) + +static bool js_cc_scene_Camera_priority_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_priority_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_priority_set) + +static bool js_cc_scene_Camera_priority_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_priority_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_priority_get) + +static bool js_cc_scene_Camera_screenScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_screenScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_screenScale_set) + +static bool js_cc_scene_Camera_screenScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Camera_screenScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_screenScale_get) + +static bool js_cc_scene_Camera_visibility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_visibility_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_visibility_set) + +static bool js_cc_scene_Camera_visibility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_visibility_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_visibility_get) + +static bool js_cc_scene_Camera_node_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Camera_node_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_node_set) + +static bool js_cc_scene_Camera_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_Camera_node_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_scene_Camera_node_get) + +static bool js_cc_scene_Camera_surfaceTransform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::gfx::SurfaceTransform result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_surfaceTransform_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_scene_Camera_surfaceTransform_get) + +static bool js_cc_scene_Camera_geometryRenderer_get(se::State& s) +{ +#if CC_USE_GEOMETRY_RENDERER + + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::pipeline::GeometryRenderer *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::pipeline::GeometryRenderer *)cc_scene_Camera_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_scene_Camera_geometryRenderer_get) + +static bool js_cc_scene_Camera_systemWindowId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_systemWindowId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_systemWindowId_get) + +static bool js_cc_scene_Camera_cameraUsage_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraUsage arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_cameraUsage_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_cameraUsage_set) + +static bool js_cc_scene_Camera_cameraUsage_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraUsage result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraUsage)cc_scene_Camera_cameraUsage_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_scene_Camera_cameraUsage_get) + +static bool js_cc_scene_Camera_trackingType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::TrackingType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_trackingType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_trackingType_set) + +static bool js_cc_scene_Camera_trackingType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::TrackingType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::TrackingType)cc_scene_Camera_trackingType_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_scene_Camera_trackingType_get) + +static bool js_cc_scene_Camera_cameraType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Camera_cameraType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Camera_cameraType_set) + +static bool js_cc_scene_Camera_cameraType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + cc::scene::CameraType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::CameraType)cc_scene_Camera_cameraType_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_scene_Camera_cameraType_get) + +static bool js_cc_scene_Camera_cameraId_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Camera *arg1 = (cc::scene::Camera *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Camera_cameraId_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Camera_cameraId_get) + +bool js_register_cc_scene_Camera(se::Object* obj) { + auto* cls = se::Class::create("Camera", obj, nullptr, _SE(js_new_cc_scene_Camera)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("iso", _SE(js_cc_scene_Camera_iso_get), _SE(js_cc_scene_Camera_iso_set)); + cls->defineProperty("isoValue", _SE(js_cc_scene_Camera_isoValue_get), nullptr); + cls->defineProperty("ec", _SE(js_cc_scene_Camera_ec_get), _SE(js_cc_scene_Camera_ec_set)); + cls->defineProperty("exposure", _SE(js_cc_scene_Camera_exposure_get), nullptr); + cls->defineProperty("shutter", _SE(js_cc_scene_Camera_shutter_get), _SE(js_cc_scene_Camera_shutter_set)); + cls->defineProperty("shutterValue", _SE(js_cc_scene_Camera_shutterValue_get), nullptr); + cls->defineProperty("apertureValue", _SE(js_cc_scene_Camera_apertureValue_get), nullptr); + cls->defineProperty("width", _SE(js_cc_scene_Camera_width_get), nullptr); + cls->defineProperty("height", _SE(js_cc_scene_Camera_height_get), nullptr); + cls->defineProperty("aspect", _SE(js_cc_scene_Camera_aspect_get), nullptr); + cls->defineProperty("scene", _SE(js_cc_scene_Camera_scene_get), nullptr); + cls->defineProperty("name", _SE(js_cc_scene_Camera_name_get), nullptr); + cls->defineProperty("window", _SE(js_cc_scene_Camera_window_get), _SE(js_cc_scene_Camera_window_set)); + cls->defineProperty("forward", _SE(js_cc_scene_Camera_forward_get), _SE(js_cc_scene_Camera_forward_set)); + cls->defineProperty("aperture", _SE(js_cc_scene_Camera_aperture_get), _SE(js_cc_scene_Camera_aperture_set)); + cls->defineProperty("position", _SE(js_cc_scene_Camera_position_get), _SE(js_cc_scene_Camera_position_set)); + cls->defineProperty("projectionType", _SE(js_cc_scene_Camera_projectionType_get), _SE(js_cc_scene_Camera_projectionType_set)); + cls->defineProperty("fovAxis", _SE(js_cc_scene_Camera_fovAxis_get), _SE(js_cc_scene_Camera_fovAxis_set)); + cls->defineProperty("fov", _SE(js_cc_scene_Camera_fov_get), _SE(js_cc_scene_Camera_fov_set)); + cls->defineProperty("nearClip", _SE(js_cc_scene_Camera_nearClip_get), _SE(js_cc_scene_Camera_nearClip_set)); + cls->defineProperty("farClip", _SE(js_cc_scene_Camera_farClip_get), _SE(js_cc_scene_Camera_farClip_set)); + cls->defineProperty("viewport", _SE(js_cc_scene_Camera_viewport_get), _SE(js_cc_scene_Camera_viewport_set)); + cls->defineProperty("orthoHeight", _SE(js_cc_scene_Camera_orthoHeight_get), _SE(js_cc_scene_Camera_orthoHeight_set)); + cls->defineProperty("clearColor", _SE(js_cc_scene_Camera_clearColor_get), _SE(js_cc_scene_Camera_clearColor_set)); + cls->defineProperty("clearDepth", _SE(js_cc_scene_Camera_clearDepth_get), _SE(js_cc_scene_Camera_clearDepth_set)); + cls->defineProperty("clearFlag", _SE(js_cc_scene_Camera_clearFlag_get), _SE(js_cc_scene_Camera_clearFlag_set)); + cls->defineProperty("clearStencil", _SE(js_cc_scene_Camera_clearStencil_get), _SE(js_cc_scene_Camera_clearStencil_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_Camera_enabled_get), _SE(js_cc_scene_Camera_enabled_set)); + cls->defineProperty("frustum", _SE(js_cc_scene_Camera_frustum_get), _SE(js_cc_scene_Camera_frustum_set)); + cls->defineProperty("isWindowSize", _SE(js_cc_scene_Camera_isWindowSize_get), _SE(js_cc_scene_Camera_isWindowSize_set)); + cls->defineProperty("priority", _SE(js_cc_scene_Camera_priority_get), _SE(js_cc_scene_Camera_priority_set)); + cls->defineProperty("screenScale", _SE(js_cc_scene_Camera_screenScale_get), _SE(js_cc_scene_Camera_screenScale_set)); + cls->defineProperty("visibility", _SE(js_cc_scene_Camera_visibility_get), _SE(js_cc_scene_Camera_visibility_set)); + cls->defineProperty("node", _SE(js_cc_scene_Camera_node_get), _SE(js_cc_scene_Camera_node_set)); + cls->defineProperty("surfaceTransform", _SE(js_cc_scene_Camera_surfaceTransform_get), nullptr); + cls->defineProperty("geometryRenderer", _SE(js_cc_scene_Camera_geometryRenderer_get), nullptr); + cls->defineProperty("systemWindowId", _SE(js_cc_scene_Camera_systemWindowId_get), nullptr); + cls->defineProperty("cameraUsage", _SE(js_cc_scene_Camera_cameraUsage_get), _SE(js_cc_scene_Camera_cameraUsage_set)); + cls->defineProperty("trackingType", _SE(js_cc_scene_Camera_trackingType_get), _SE(js_cc_scene_Camera_trackingType_set)); + cls->defineProperty("cameraType", _SE(js_cc_scene_Camera_cameraType_get), _SE(js_cc_scene_Camera_cameraType_set)); + cls->defineProperty("cameraId", _SE(js_cc_scene_Camera_cameraId_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_Camera_initialize)); + cls->defineFunction("destroy", _SE(js_cc_scene_Camera_destroy)); + cls->defineFunction("attachToScene", _SE(js_cc_scene_Camera_attachToScene)); + cls->defineFunction("detachFromScene", _SE(js_cc_scene_Camera_detachFromScene)); + cls->defineFunction("resize", _SE(js_cc_scene_Camera_resize)); + cls->defineFunction("setFixedSize", _SE(js_cc_scene_Camera_setFixedSize)); + cls->defineFunction("syncCameraEditor", _SE(js_cc_scene_Camera_syncCameraEditor)); + cls->defineFunction("update", _SE(js_cc_scene_Camera_update)); + cls->defineFunction("changeTargetWindow", _SE(js_cc_scene_Camera_changeTargetWindow)); + cls->defineFunction("setViewportInOrientedSpace", _SE(js_cc_scene_Camera_setViewportInOrientedSpace)); + cls->defineFunction("initGeometryRenderer", _SE(js_cc_scene_Camera_initGeometryRenderer)); + cls->defineFunction("detachCamera", _SE(js_cc_scene_Camera_detachCamera)); + cls->defineFunction("isCullingEnabled", _SE(js_cc_scene_Camera_isCullingEnabled)); + cls->defineFunction("setCullingEnable", _SE(js_cc_scene_Camera_setCullingEnable)); + cls->defineFunction("calculateObliqueMat", _SE(js_cc_scene_Camera_calculateObliqueMat)); + cls->defineFunction("getClipSpaceMinz", _SE(js_cc_scene_Camera_getClipSpaceMinz)); + + + cls->defineStaticFunction("getStandardExposureValue", _SE(js_cc_scene_Camera_getStandardExposureValue_static)); + cls->defineStaticFunction("getStandardLightMeterScale", _SE(js_cc_scene_Camera_getStandardLightMeterScale_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Camera)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Camera_proto = cls->getProto(); + __jsb_cc_scene_Camera_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Ambient_class = nullptr; +se::Object* __jsb_cc_scene_Ambient_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Ambient) + +static bool js_new_cc_scene_Ambient(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Ambient *result; + result = (cc::scene::Ambient *)new cc::scene::Ambient(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Ambient, __jsb_cc_scene_Ambient_class, js_delete_cc_scene_Ambient) + +static bool js_delete_cc_scene_Ambient(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Ambient) + +static bool js_cc_scene_Ambient_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::scene::AmbientInfo *arg2 = (cc::scene::AmbientInfo *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initialize(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Ambient_initialize) + +static bool js_cc_scene_Ambient_skyColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Ambient_skyColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_skyColor_set) + +static bool js_cc_scene_Ambient_skyColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_Ambient_skyColor_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_scene_Ambient_skyColor_get) + +static bool js_cc_scene_Ambient_skyIllum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Ambient_skyIllum_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_skyIllum_set) + +static bool js_cc_scene_Ambient_skyIllum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_Ambient_skyIllum_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Ambient_skyIllum_get) + +static bool js_cc_scene_Ambient_groundAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_Ambient_groundAlbedo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_groundAlbedo_set) + +static bool js_cc_scene_Ambient_groundAlbedo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_Ambient_groundAlbedo_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_scene_Ambient_groundAlbedo_get) + +static bool js_cc_scene_Ambient_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_Ambient_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_enabled_set) + +static bool js_cc_scene_Ambient_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_Ambient_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Ambient_enabled_get) + +static bool js_cc_scene_Ambient_mipmapCount_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + uint8_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_Ambient_mipmapCount_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_Ambient_mipmapCount_set) + +static bool js_cc_scene_Ambient_mipmapCount_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::Ambient *arg1 = (cc::scene::Ambient *) NULL ; + uint8_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_Ambient_mipmapCount_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_Ambient_mipmapCount_get) + +bool js_register_cc_scene_Ambient(se::Object* obj) { + auto* cls = se::Class::create("Ambient", obj, nullptr, _SE(js_new_cc_scene_Ambient)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("skyColor", _SE(js_cc_scene_Ambient_skyColor_get), _SE(js_cc_scene_Ambient_skyColor_set)); + cls->defineProperty("skyIllum", _SE(js_cc_scene_Ambient_skyIllum_get), _SE(js_cc_scene_Ambient_skyIllum_set)); + cls->defineProperty("groundAlbedo", _SE(js_cc_scene_Ambient_groundAlbedo_get), _SE(js_cc_scene_Ambient_groundAlbedo_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_Ambient_enabled_get), _SE(js_cc_scene_Ambient_enabled_set)); + cls->defineProperty("mipmapCount", _SE(js_cc_scene_Ambient_mipmapCount_get), _SE(js_cc_scene_Ambient_mipmapCount_set)); + + cls->defineFunction("initialize", _SE(js_cc_scene_Ambient_initialize)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Ambient)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Ambient_proto = cls->getProto(); + __jsb_cc_scene_Ambient_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_AmbientInfo_class = nullptr; +se::Object* __jsb_cc_scene_AmbientInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_AmbientInfo) + +static bool js_new_cc_scene_AmbientInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::AmbientInfo *result; + result = (cc::scene::AmbientInfo *)new cc::scene::AmbientInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_AmbientInfo, __jsb_cc_scene_AmbientInfo_class, js_delete_cc_scene_AmbientInfo) + +static bool js_delete_cc_scene_AmbientInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_AmbientInfo) + +static bool js_cc_scene_AmbientInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::scene::Ambient *arg2 = (cc::scene::Ambient *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_AmbientInfo_activate) + +static bool js_cc_scene_AmbientInfo__skyColorHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyColorHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyColorHDR_set) + +static bool js_cc_scene_AmbientInfo__skyColorHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyColorHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_skyColorHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyColorHDR_get) + +static bool js_cc_scene_AmbientInfo__skyIllumHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyIllumHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyIllumHDR_set) + +static bool js_cc_scene_AmbientInfo__skyIllumHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyIllumHDR, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyIllumHDR_get) + +static bool js_cc_scene_AmbientInfo__groundAlbedoHDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_groundAlbedoHDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__groundAlbedoHDR_set) + +static bool js_cc_scene_AmbientInfo__groundAlbedoHDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_groundAlbedoHDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_groundAlbedoHDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__groundAlbedoHDR_get) + +static bool js_cc_scene_AmbientInfo__skyColorLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyColorLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyColorLDR_set) + +static bool js_cc_scene_AmbientInfo__skyColorLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyColorLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_skyColorLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyColorLDR_get) + +static bool js_cc_scene_AmbientInfo__skyIllumLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_skyIllumLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyIllumLDR_set) + +static bool js_cc_scene_AmbientInfo__skyIllumLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_skyIllumLDR, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyIllumLDR_get) + +static bool js_cc_scene_AmbientInfo__groundAlbedoLDR_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_groundAlbedoLDR, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__groundAlbedoLDR_set) + +static bool js_cc_scene_AmbientInfo__groundAlbedoLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_groundAlbedoLDR, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_groundAlbedoLDR, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__groundAlbedoLDR_get) + +static bool js_cc_scene_AmbientInfo_skyColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_skyColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_skyColor_set) + +static bool js_cc_scene_AmbientInfo_skyIllum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_AmbientInfo_skyIllum_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_skyIllum_set) + +static bool js_cc_scene_AmbientInfo_skyIllum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_AmbientInfo_skyIllum_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo_skyIllum_get) + +static bool js_cc_scene_AmbientInfo_groundAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_groundAlbedo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_groundAlbedo_set) + +static bool js_cc_scene_AmbientInfo__skyColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo__skyColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyColor_set) + +static bool js_cc_scene_AmbientInfo__skyColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo__skyColor_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_scene_AmbientInfo__skyColor_get) + +static bool js_cc_scene_AmbientInfo__skyIllum_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_AmbientInfo__skyIllum_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__skyIllum_set) + +static bool js_cc_scene_AmbientInfo__skyIllum_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_AmbientInfo__skyIllum_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo__skyIllum_get) + +static bool js_cc_scene_AmbientInfo__groundAlbedo_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *arg2 = 0 ; + cc::Vec4 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo__groundAlbedo_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo__groundAlbedo_set) + +static bool js_cc_scene_AmbientInfo__groundAlbedo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo__groundAlbedo_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_scene_AmbientInfo__groundAlbedo_get) + +static bool js_cc_scene_AmbientInfo_skyColorLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo_skyColorLDR_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_scene_AmbientInfo_skyColorLDR_get) + +static bool js_cc_scene_AmbientInfo_groundAlbedoLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Vec4 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec4 *) &cc_scene_AmbientInfo_groundAlbedoLDR_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_scene_AmbientInfo_groundAlbedoLDR_get) + +static bool js_cc_scene_AmbientInfo_skyIllumLDR_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)cc_scene_AmbientInfo_skyIllumLDR_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_AmbientInfo_skyIllumLDR_get) + +static bool js_cc_scene_AmbientInfo_skyLightingColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_skyLightingColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_skyLightingColor_set) + +static bool js_cc_scene_AmbientInfo_skyLightingColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_AmbientInfo_skyLightingColor_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_scene_AmbientInfo_skyLightingColor_get) + +static bool js_cc_scene_AmbientInfo_groundLightingColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *arg2 = 0 ; + cc::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_AmbientInfo_groundLightingColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_AmbientInfo_groundLightingColor_set) + +static bool js_cc_scene_AmbientInfo_groundLightingColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::AmbientInfo *arg1 = (cc::scene::AmbientInfo *) NULL ; + cc::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Color *) &cc_scene_AmbientInfo_groundLightingColor_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_scene_AmbientInfo_groundLightingColor_get) + +bool js_register_cc_scene_AmbientInfo(se::Object* obj) { + auto* cls = se::Class::create("AmbientInfo", obj, nullptr, _SE(js_new_cc_scene_AmbientInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_skyColorHDR", _SE(js_cc_scene_AmbientInfo__skyColorHDR_get), _SE(js_cc_scene_AmbientInfo__skyColorHDR_set)); + cls->defineProperty("_skyIllumHDR", _SE(js_cc_scene_AmbientInfo__skyIllumHDR_get), _SE(js_cc_scene_AmbientInfo__skyIllumHDR_set)); + cls->defineProperty("_groundAlbedoHDR", _SE(js_cc_scene_AmbientInfo__groundAlbedoHDR_get), _SE(js_cc_scene_AmbientInfo__groundAlbedoHDR_set)); + cls->defineProperty("_skyColorLDR", _SE(js_cc_scene_AmbientInfo__skyColorLDR_get), _SE(js_cc_scene_AmbientInfo__skyColorLDR_set)); + cls->defineProperty("_skyIllumLDR", _SE(js_cc_scene_AmbientInfo__skyIllumLDR_get), _SE(js_cc_scene_AmbientInfo__skyIllumLDR_set)); + cls->defineProperty("_groundAlbedoLDR", _SE(js_cc_scene_AmbientInfo__groundAlbedoLDR_get), _SE(js_cc_scene_AmbientInfo__groundAlbedoLDR_set)); + cls->defineProperty("skyColor", nullptr, _SE(js_cc_scene_AmbientInfo_skyColor_set)); + cls->defineProperty("skyIllum", _SE(js_cc_scene_AmbientInfo_skyIllum_get), _SE(js_cc_scene_AmbientInfo_skyIllum_set)); + cls->defineProperty("groundAlbedo", nullptr, _SE(js_cc_scene_AmbientInfo_groundAlbedo_set)); + cls->defineProperty("_skyColor", _SE(js_cc_scene_AmbientInfo__skyColor_get), _SE(js_cc_scene_AmbientInfo__skyColor_set)); + cls->defineProperty("_skyIllum", _SE(js_cc_scene_AmbientInfo__skyIllum_get), _SE(js_cc_scene_AmbientInfo__skyIllum_set)); + cls->defineProperty("_groundAlbedo", _SE(js_cc_scene_AmbientInfo__groundAlbedo_get), _SE(js_cc_scene_AmbientInfo__groundAlbedo_set)); + cls->defineProperty("skyColorLDR", _SE(js_cc_scene_AmbientInfo_skyColorLDR_get), nullptr); + cls->defineProperty("groundAlbedoLDR", _SE(js_cc_scene_AmbientInfo_groundAlbedoLDR_get), nullptr); + cls->defineProperty("skyIllumLDR", _SE(js_cc_scene_AmbientInfo_skyIllumLDR_get), nullptr); + cls->defineProperty("skyLightingColor", _SE(js_cc_scene_AmbientInfo_skyLightingColor_get), _SE(js_cc_scene_AmbientInfo_skyLightingColor_set)); + cls->defineProperty("groundLightingColor", _SE(js_cc_scene_AmbientInfo_groundLightingColor_get), _SE(js_cc_scene_AmbientInfo_groundLightingColor_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_AmbientInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_AmbientInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_AmbientInfo_proto = cls->getProto(); + __jsb_cc_scene_AmbientInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_ReflectionProbe_class = nullptr; +se::Object* __jsb_cc_scene_ReflectionProbe_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_ReflectionProbe) + +static bool js_new_cc_scene_ReflectionProbe(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int32_t arg1 ; + cc::scene::ReflectionProbe *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::scene::ReflectionProbe *)new cc::scene::ReflectionProbe(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_ReflectionProbe, __jsb_cc_scene_ReflectionProbe_class, js_delete_cc_scene_ReflectionProbe) + +static bool js_delete_cc_scene_ReflectionProbe(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_ReflectionProbe) + +static bool js_cc_scene_ReflectionProbe_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + cc::Node *arg3 = (cc::Node *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_initialize) + +static bool js_cc_scene_ReflectionProbe_getProbeId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + int32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::ReflectionProbe const *)arg1)->getProbeId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_getProbeId) + +static bool js_cc_scene_ReflectionProbe_needRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::ReflectionProbe const *)arg1)->needRender(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_needRender) + +static bool js_cc_scene_ReflectionProbe_setNeedRender(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setNeedRender(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_setNeedRender) + +static bool js_cc_scene_ReflectionProbe_setCameraNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCameraNode(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_setCameraNode) + +static bool js_cc_scene_ReflectionProbe_getCameraNode(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *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(s); + if (nullptr == arg1) return true; + result = (cc::Node *)((cc::scene::ReflectionProbe const *)arg1)->getCameraNode(); + + 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_scene_ReflectionProbe_getCameraNode) + +static bool js_cc_scene_ReflectionProbe_updateBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateBoundingBox(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_updateBoundingBox) + +static bool js_cc_scene_ReflectionProbe_syncCameraParams(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->syncCameraParams((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_syncCameraParams) + +static bool js_cc_scene_ReflectionProbe_transformReflectionCamera(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->transformReflectionCamera((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_transformReflectionCamera) + +static bool js_cc_scene_ReflectionProbe_renderPlanarReflection(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->renderPlanarReflection((cc::scene::Camera const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_renderPlanarReflection) + +static bool js_cc_scene_ReflectionProbe_switchProbeType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + int32_t arg2 ; + cc::scene::Camera *arg3 = (cc::scene::Camera *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->switchProbeType(arg2,(cc::scene::Camera const *)arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_switchProbeType) + +static bool js_cc_scene_ReflectionProbe_reflect_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::Vec3 *arg1 = 0 ; + cc::Vec3 *arg2 = 0 ; + float arg3 ; + cc::Vec3 temp1 ; + cc::Vec3 temp2 ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = cc::scene::ReflectionProbe::reflect((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2,arg3); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_reflect_static) + +static bool js_cc_scene_ReflectionProbe_updatePlanarTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::RenderScene *arg2 = (cc::scene::RenderScene *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updatePlanarTexture((cc::scene::RenderScene const *)arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_updatePlanarTexture) + +static bool js_cc_scene_ReflectionProbe_destroy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->destroy(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_destroy) + +static bool js_cc_scene_ReflectionProbe_enable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->enable(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_enable) + +static bool js_cc_scene_ReflectionProbe_disable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->disable(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_disable) + +static bool js_cc_scene_ReflectionProbe_validate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::ReflectionProbe const *)arg1)->validate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_validate) + +static bool js_cc_scene_ReflectionProbe_initBakedTextures(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initBakedTextures(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_initBakedTextures) + +static bool js_cc_scene_ReflectionProbe_captureCubemap(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->captureCubemap(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_captureCubemap) + +static bool js_cc_scene_ReflectionProbe_resetCameraParams(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetCameraParams(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_resetCameraParams) + +static bool js_cc_scene_ReflectionProbe_updateCameraDir(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + int32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateCameraDir(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_updateCameraDir) + +static bool js_cc_scene_ReflectionProbe_renderArea(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Vec2 result; + cc::Vec2 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::ReflectionProbe const *)arg1)->renderArea(); + + temp = ccnew cc::Vec2(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_renderArea) + +static bool js_cc_scene_ReflectionProbe_packBackgroundColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->packBackgroundColor(); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_packBackgroundColor) + +static bool js_cc_scene_ReflectionProbe_isRGBE(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::ReflectionProbe const *)arg1)->isRGBE(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_ReflectionProbe_isRGBE) + +static bool js_cc_scene_ReflectionProbe_probeType_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::ReflectionProbe::ProbeType arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_probeType_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_probeType_set) + +static bool js_cc_scene_ReflectionProbe_probeType_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::ReflectionProbe::ProbeType result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::ReflectionProbe::ProbeType)cc_scene_ReflectionProbe_probeType_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_scene_ReflectionProbe_probeType_get) + +static bool js_cc_scene_ReflectionProbe_resolution_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_resolution_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_resolution_set) + +static bool js_cc_scene_ReflectionProbe_resolution_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ReflectionProbe_resolution_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ReflectionProbe_resolution_get) + +static bool js_cc_scene_ReflectionProbe_clearFlag_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::ClearFlagBit arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_clearFlag_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_clearFlag_set) + +static bool js_cc_scene_ReflectionProbe_clearFlag_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::ClearFlagBit result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ReflectionProbe_clearFlag_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_scene_ReflectionProbe_clearFlag_get) + +static bool js_cc_scene_ReflectionProbe_backgroundColor_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::Color *arg2 = 0 ; + cc::gfx::Color temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ReflectionProbe_backgroundColor_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_backgroundColor_set) + +static bool js_cc_scene_ReflectionProbe_backgroundColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::gfx::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::gfx::Color *) &cc_scene_ReflectionProbe_backgroundColor_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_scene_ReflectionProbe_backgroundColor_get) + +static bool js_cc_scene_ReflectionProbe_visibility_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_ReflectionProbe_visibility_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_visibility_set) + +static bool js_cc_scene_ReflectionProbe_visibility_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_ReflectionProbe_visibility_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_ReflectionProbe_visibility_get) + +static bool js_cc_scene_ReflectionProbe_size_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_ReflectionProbe_size_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_size_set) + +static bool js_cc_scene_ReflectionProbe_size_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_ReflectionProbe_size_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_scene_ReflectionProbe_size_get) + +static bool js_cc_scene_ReflectionProbe_boundingBox_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::geometry::AABB *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::geometry::AABB *)cc_scene_ReflectionProbe_boundingBox_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_scene_ReflectionProbe_boundingBox_get) + +static bool js_cc_scene_ReflectionProbe_previewSphere_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ReflectionProbe_previewSphere_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_previewSphere_set) + +static bool js_cc_scene_ReflectionProbe_previewSphere_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_ReflectionProbe_previewSphere_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_scene_ReflectionProbe_previewSphere_get) + +static bool js_cc_scene_ReflectionProbe_previewPlane_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *arg2 = (cc::Node *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ReflectionProbe_previewPlane_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_previewPlane_set) + +static bool js_cc_scene_ReflectionProbe_previewPlane_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_ReflectionProbe_previewPlane_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_scene_ReflectionProbe_previewPlane_get) + +static bool js_cc_scene_ReflectionProbe_bakedCubeTextures_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + ccstd::vector< cc::IntrusivePtr< cc::RenderTexture > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (ccstd::vector< cc::IntrusivePtr< cc::RenderTexture > > *) &cc_scene_ReflectionProbe_bakedCubeTextures_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_scene_ReflectionProbe_bakedCubeTextures_get) + +static bool js_cc_scene_ReflectionProbe_cubemap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::TextureCube *arg2 = (cc::TextureCube *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_ReflectionProbe_cubemap_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_ReflectionProbe_cubemap_set) + +static bool js_cc_scene_ReflectionProbe_cubemap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::TextureCube *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::TextureCube *)cc_scene_ReflectionProbe_cubemap_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_scene_ReflectionProbe_cubemap_get) + +static bool js_cc_scene_ReflectionProbe_node_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::Node *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Node *)cc_scene_ReflectionProbe_node_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_scene_ReflectionProbe_node_get) + +static bool js_cc_scene_ReflectionProbe_realtimePlanarTexture_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::RenderTexture *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::RenderTexture *)cc_scene_ReflectionProbe_realtimePlanarTexture_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_scene_ReflectionProbe_realtimePlanarTexture_get) + +static bool js_cc_scene_ReflectionProbe_camera_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::ReflectionProbe *arg1 = (cc::scene::ReflectionProbe *) NULL ; + cc::scene::Camera *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Camera *)cc_scene_ReflectionProbe_camera_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_scene_ReflectionProbe_camera_get) + +bool js_register_cc_scene_ReflectionProbe(se::Object* obj) { + auto* cls = se::Class::create("ReflectionProbe", obj, nullptr, _SE(js_new_cc_scene_ReflectionProbe)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("probeType", _SE(js_cc_scene_ReflectionProbe_probeType_get), _SE(js_cc_scene_ReflectionProbe_probeType_set)); + cls->defineProperty("resolution", _SE(js_cc_scene_ReflectionProbe_resolution_get), _SE(js_cc_scene_ReflectionProbe_resolution_set)); + cls->defineProperty("clearFlag", _SE(js_cc_scene_ReflectionProbe_clearFlag_get), _SE(js_cc_scene_ReflectionProbe_clearFlag_set)); + cls->defineProperty("backgroundColor", _SE(js_cc_scene_ReflectionProbe_backgroundColor_get), _SE(js_cc_scene_ReflectionProbe_backgroundColor_set)); + cls->defineProperty("visibility", _SE(js_cc_scene_ReflectionProbe_visibility_get), _SE(js_cc_scene_ReflectionProbe_visibility_set)); + cls->defineProperty("size", _SE(js_cc_scene_ReflectionProbe_size_get), _SE(js_cc_scene_ReflectionProbe_size_set)); + cls->defineProperty("boundingBox", _SE(js_cc_scene_ReflectionProbe_boundingBox_get), nullptr); + cls->defineProperty("previewSphere", _SE(js_cc_scene_ReflectionProbe_previewSphere_get), _SE(js_cc_scene_ReflectionProbe_previewSphere_set)); + cls->defineProperty("previewPlane", _SE(js_cc_scene_ReflectionProbe_previewPlane_get), _SE(js_cc_scene_ReflectionProbe_previewPlane_set)); + cls->defineProperty("bakedCubeTextures", _SE(js_cc_scene_ReflectionProbe_bakedCubeTextures_get), nullptr); + cls->defineProperty("cubemap", _SE(js_cc_scene_ReflectionProbe_cubemap_get), _SE(js_cc_scene_ReflectionProbe_cubemap_set)); + cls->defineProperty("node", _SE(js_cc_scene_ReflectionProbe_node_get), nullptr); + cls->defineProperty("realtimePlanarTexture", _SE(js_cc_scene_ReflectionProbe_realtimePlanarTexture_get), nullptr); + cls->defineProperty("camera", _SE(js_cc_scene_ReflectionProbe_camera_get), nullptr); + + cls->defineFunction("initialize", _SE(js_cc_scene_ReflectionProbe_initialize)); + cls->defineFunction("getProbeId", _SE(js_cc_scene_ReflectionProbe_getProbeId)); + cls->defineFunction("needRender", _SE(js_cc_scene_ReflectionProbe_needRender)); + cls->defineFunction("setNeedRender", _SE(js_cc_scene_ReflectionProbe_setNeedRender)); + cls->defineFunction("setCameraNode", _SE(js_cc_scene_ReflectionProbe_setCameraNode)); + cls->defineFunction("getCameraNode", _SE(js_cc_scene_ReflectionProbe_getCameraNode)); + cls->defineFunction("updateBoundingBox", _SE(js_cc_scene_ReflectionProbe_updateBoundingBox)); + cls->defineFunction("syncCameraParams", _SE(js_cc_scene_ReflectionProbe_syncCameraParams)); + cls->defineFunction("transformReflectionCamera", _SE(js_cc_scene_ReflectionProbe_transformReflectionCamera)); + cls->defineFunction("renderPlanarReflection", _SE(js_cc_scene_ReflectionProbe_renderPlanarReflection)); + cls->defineFunction("switchProbeType", _SE(js_cc_scene_ReflectionProbe_switchProbeType)); + cls->defineFunction("updatePlanarTexture", _SE(js_cc_scene_ReflectionProbe_updatePlanarTexture)); + cls->defineFunction("destroy", _SE(js_cc_scene_ReflectionProbe_destroy)); + cls->defineFunction("enable", _SE(js_cc_scene_ReflectionProbe_enable)); + cls->defineFunction("disable", _SE(js_cc_scene_ReflectionProbe_disable)); + cls->defineFunction("validate", _SE(js_cc_scene_ReflectionProbe_validate)); + cls->defineFunction("initBakedTextures", _SE(js_cc_scene_ReflectionProbe_initBakedTextures)); + cls->defineFunction("captureCubemap", _SE(js_cc_scene_ReflectionProbe_captureCubemap)); + cls->defineFunction("resetCameraParams", _SE(js_cc_scene_ReflectionProbe_resetCameraParams)); + cls->defineFunction("updateCameraDir", _SE(js_cc_scene_ReflectionProbe_updateCameraDir)); + cls->defineFunction("renderArea", _SE(js_cc_scene_ReflectionProbe_renderArea)); + cls->defineFunction("packBackgroundColor", _SE(js_cc_scene_ReflectionProbe_packBackgroundColor)); + cls->defineFunction("isRGBE", _SE(js_cc_scene_ReflectionProbe_isRGBE)); + + + cls->defineStaticFunction("reflect", _SE(js_cc_scene_ReflectionProbe_reflect_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_ReflectionProbe)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_ReflectionProbe_proto = cls->getProto(); + __jsb_cc_scene_ReflectionProbe_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_PassInstance_class = nullptr; +se::Object* __jsb_cc_PassInstance_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_PassInstance) + +static bool js_new_cc_PassInstance(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + cc::scene::Pass *arg1 = (cc::scene::Pass *) NULL ; + cc::MaterialInstance *arg2 = (cc::MaterialInstance *) NULL ; + cc::PassInstance *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::PassInstance *)new cc::PassInstance(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_PassInstance, __jsb_cc_PassInstance_class, js_delete_cc_PassInstance) + +static bool js_delete_cc_PassInstance(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_PassInstance) + +static bool js_cc_PassInstance_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::PassInstance *arg1 = (cc::PassInstance *) NULL ; + cc::scene::Pass *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::scene::Pass *)cc_PassInstance_parent_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_PassInstance_parent_get) + +bool js_register_cc_PassInstance(se::Object* obj) { + auto* cls = se::Class::create("PassInstance", obj, __jsb_cc_scene_Pass_proto, _SE(js_new_cc_PassInstance)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("parent", _SE(js_cc_PassInstance_parent_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_PassInstance)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_PassInstance_proto = cls->getProto(); + __jsb_cc_PassInstance_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMaterialInstanceInfo_class = nullptr; +se::Object* __jsb_cc_IMaterialInstanceInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMaterialInstanceInfo) + +static bool js_cc_IMaterialInstanceInfo_parent_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->parent, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInstanceInfo_parent_set) + +static bool js_cc_IMaterialInstanceInfo_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->parent, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->parent, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInstanceInfo_parent_get) + +static bool js_cc_IMaterialInstanceInfo_subModelIdx_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->subModelIdx, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMaterialInstanceInfo_subModelIdx_set) + +static bool js_cc_IMaterialInstanceInfo_subModelIdx_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMaterialInstanceInfo *arg1 = (cc::IMaterialInstanceInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->subModelIdx, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMaterialInstanceInfo_subModelIdx_get) + +static bool js_new_cc_IMaterialInstanceInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMaterialInstanceInfo *result; + result = (cc::IMaterialInstanceInfo *)new cc::IMaterialInstanceInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMaterialInstanceInfo, __jsb_cc_IMaterialInstanceInfo_class, js_delete_cc_IMaterialInstanceInfo) + +static bool js_delete_cc_IMaterialInstanceInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMaterialInstanceInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInstanceInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("parent", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->parent), ctx); + } + + + json->getProperty("subModelIdx", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->subModelIdx), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMaterialInstanceInfo(se::Object* obj) { + auto* cls = se::Class::create("IMaterialInstanceInfo", obj, nullptr, _SE(js_new_cc_IMaterialInstanceInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("parent", _SE(js_cc_IMaterialInstanceInfo_parent_get), _SE(js_cc_IMaterialInstanceInfo_parent_set)); + cls->defineProperty("subModelIdx", _SE(js_cc_IMaterialInstanceInfo_subModelIdx_get), _SE(js_cc_IMaterialInstanceInfo_subModelIdx_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMaterialInstanceInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMaterialInstanceInfo_proto = cls->getProto(); + __jsb_cc_IMaterialInstanceInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MaterialInstance_class = nullptr; +se::Object* __jsb_cc_MaterialInstance_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MaterialInstance) + +static bool js_new_cc_MaterialInstance(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + cc::IMaterialInstanceInfo *arg1 = 0 ; + cc::IMaterialInstanceInfo temp1 ; + cc::MaterialInstance *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::MaterialInstance *)new cc::MaterialInstance((cc::IMaterialInstanceInfo const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MaterialInstance, __jsb_cc_MaterialInstance_class, js_delete_cc_MaterialInstance) + +static bool js_cc_MaterialInstance_recompileShaders__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::MacroRecord *arg2 = 0 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2); + + + return true; +} + +static bool js_cc_MaterialInstance_recompileShaders__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::MacroRecord *arg2 = 0 ; + index_t arg3 ; + cc::MacroRecord temp2 ; + + arg1 = SE_THIS_OBJECT(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)->recompileShaders((cc::MacroRecord const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_MaterialInstance_recompileShaders(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_MaterialInstance_recompileShaders__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MaterialInstance_recompileShaders__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MaterialInstance_recompileShaders) + +static bool js_cc_MaterialInstance_overridePipelineStates__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::PassOverrides *arg2 = 0 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2); + + + return true; +} + +static bool js_cc_MaterialInstance_overridePipelineStates__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::PassOverrides *arg2 = 0 ; + index_t arg3 ; + cc::PassOverrides temp2 ; + + arg1 = SE_THIS_OBJECT(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)->overridePipelineStates((cc::PassOverrides const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_MaterialInstance_overridePipelineStates(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_MaterialInstance_overridePipelineStates__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_MaterialInstance_overridePipelineStates__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_MaterialInstance_overridePipelineStates) + +static bool js_cc_MaterialInstance_onPassStateChange(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->onPassStateChange(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MaterialInstance_onPassStateChange) + +static bool js_cc_MaterialInstance_setRebuildPSOCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MaterialInstance *arg1 = (cc::MaterialInstance *) NULL ; + cc::MaterialInstance::RebuildPSOCallback *arg2 = 0 ; + cc::MaterialInstance::RebuildPSOCallback temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setRebuildPSOCallback((cc::MaterialInstance::RebuildPSOCallback const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MaterialInstance_setRebuildPSOCallback) + +static bool js_delete_cc_MaterialInstance(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MaterialInstance) + +bool js_register_cc_MaterialInstance(se::Object* obj) { + auto* cls = se::Class::create("MaterialInstance", obj, __jsb_cc_Material_proto, _SE(js_new_cc_MaterialInstance)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("recompileShaders", _SE(js_cc_MaterialInstance_recompileShaders)); + cls->defineFunction("overridePipelineStates", _SE(js_cc_MaterialInstance_overridePipelineStates)); + cls->defineFunction("onPassStateChange", _SE(js_cc_MaterialInstance_onPassStateChange)); + cls->defineFunction("setRebuildPSOCallback", _SE(js_cc_MaterialInstance_setRebuildPSOCallback)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MaterialInstance)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MaterialInstance_proto = cls->getProto(); + __jsb_cc_MaterialInstance_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_MorphModel_class = nullptr; +se::Object* __jsb_cc_MorphModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_MorphModel) + +static bool js_new_cc_MorphModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::MorphModel *result; + result = (cc::MorphModel *)new cc::MorphModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_MorphModel, __jsb_cc_MorphModel_class, js_delete_cc_MorphModel) + +static bool js_delete_cc_MorphModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_MorphModel) + +static bool js_cc_MorphModel_setMorphRendering(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::MorphModel *arg1 = (cc::MorphModel *) NULL ; + cc::MorphRenderingInstance *arg2 = (cc::MorphRenderingInstance *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMorphRendering(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_MorphModel_setMorphRendering) + +bool js_register_cc_MorphModel(se::Object* obj) { + auto* cls = se::Class::create("MorphModel", obj, __jsb_cc_scene_Model_proto, _SE(js_new_cc_MorphModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setMorphRendering", _SE(js_cc_MorphModel_setMorphRendering)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_MorphModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_MorphModel_proto = cls->getProto(); + __jsb_cc_MorphModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkinningModel_class = nullptr; +se::Object* __jsb_cc_SkinningModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkinningModel) + +static bool js_new_cc_SkinningModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkinningModel *result; + result = (cc::SkinningModel *)new cc::SkinningModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkinningModel, __jsb_cc_SkinningModel_class, js_delete_cc_SkinningModel) + +static bool js_delete_cc_SkinningModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkinningModel) + +static bool js_cc_SkinningModel_bindSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkinningModel *arg1 = (cc::SkinningModel *) NULL ; + cc::Skeleton *arg2 = (cc::Skeleton *) NULL ; + cc::Node *arg3 = (cc::Node *) NULL ; + cc::Mesh *arg4 = (cc::Mesh *) NULL ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindSkeleton(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_SkinningModel_bindSkeleton) + +bool js_register_cc_SkinningModel(se::Object* obj) { + auto* cls = se::Class::create("SkinningModel", obj, __jsb_cc_MorphModel_proto, _SE(js_new_cc_SkinningModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("bindSkeleton", _SE(js_cc_SkinningModel_bindSkeleton)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkinningModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkinningModel_proto = cls->getProto(); + __jsb_cc_SkinningModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_BakedSkinningModel_class = nullptr; +se::Object* __jsb_cc_BakedSkinningModel_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_BakedSkinningModel) + +static bool js_new_cc_BakedSkinningModel(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::BakedSkinningModel *result; + result = (cc::BakedSkinningModel *)new cc::BakedSkinningModel(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_BakedSkinningModel, __jsb_cc_BakedSkinningModel_class, js_delete_cc_BakedSkinningModel) + +static bool js_delete_cc_BakedSkinningModel(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_BakedSkinningModel) + +static bool js_cc_BakedSkinningModel_updateInstancedJointTextureInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateInstancedJointTextureInfo(); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_updateInstancedJointTextureInfo) + +static bool js_cc_BakedSkinningModel_bindSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + cc::Skeleton *arg2 = (cc::Skeleton *) NULL ; + cc::Node *arg3 = (cc::Node *) NULL ; + cc::Mesh *arg4 = (cc::Mesh *) NULL ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->bindSkeleton(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_bindSkeleton) + +static bool js_cc_BakedSkinningModel_updateModelBounds(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + cc::geometry::AABB *arg2 = (cc::geometry::AABB *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->updateModelBounds(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_updateModelBounds) + +static bool js_cc_BakedSkinningModel_syncAnimInfoForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + cc::gfx::Buffer *arg2 = (cc::gfx::Buffer *) NULL ; + cc::Float32Array *arg3 = 0 ; + cc::Uint8Array *arg4 = 0 ; + cc::Float32Array temp3 ; + cc::Uint8Array temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + (arg1)->syncAnimInfoForJS(arg2,(cc::Float32Array const &)*arg3,*arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_syncAnimInfoForJS) + +static bool js_cc_BakedSkinningModel_syncDataForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + ccstd::vector< ccstd::optional< cc::geometry::AABB > > *arg2 = 0 ; + ccstd::optional< cc::geometry::AABB > *arg3 = 0 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + cc::gfx::Texture *arg8 = (cc::gfx::Texture *) NULL ; + cc::Float32Array *arg9 = 0 ; + ccstd::vector< ccstd::optional< cc::geometry::AABB > > temp2 ; + ccstd::optional< cc::geometry::AABB > temp3 ; + cc::Float32Array temp9 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &temp9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg9 = &temp9; + + (arg1)->syncDataForJS((ccstd::vector< ccstd::optional< cc::geometry::AABB > > const &)*arg2,(ccstd::optional< cc::geometry::AABB > const &)*arg3,arg4,arg5,arg6,arg7,arg8,(cc::Float32Array const &)*arg9); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_syncDataForJS) + +static bool js_cc_BakedSkinningModel_setUploadedAnimForJS(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::BakedSkinningModel *arg1 = (cc::BakedSkinningModel *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUploadedAnimForJS(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_BakedSkinningModel_setUploadedAnimForJS) + +bool js_register_cc_BakedSkinningModel(se::Object* obj) { + auto* cls = se::Class::create("BakedSkinningModel", obj, __jsb_cc_MorphModel_proto, _SE(js_new_cc_BakedSkinningModel)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("updateInstancedJointTextureInfo", _SE(js_cc_BakedSkinningModel_updateInstancedJointTextureInfo)); + cls->defineFunction("bindSkeleton", _SE(js_cc_BakedSkinningModel_bindSkeleton)); + cls->defineFunction("updateModelBounds", _SE(js_cc_BakedSkinningModel_updateModelBounds)); + cls->defineFunction("syncAnimInfoForJS", _SE(js_cc_BakedSkinningModel_syncAnimInfoForJS)); + cls->defineFunction("syncDataForJS", _SE(js_cc_BakedSkinningModel_syncDataForJS)); + cls->defineFunction("setUploadedAnimForJS", _SE(js_cc_BakedSkinningModel_setUploadedAnimForJS)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_BakedSkinningModel)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_BakedSkinningModel_proto = cls->getProto(); + __jsb_cc_BakedSkinningModel_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IDefineRecord_class = nullptr; +se::Object* __jsb_cc_IDefineRecord_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IDefineRecord) + +static bool js_cc_IDefineRecord_map_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->map, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineRecord_map_set) + +static bool js_cc_IDefineRecord_map_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->map, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->map, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineRecord_map_get) + +static bool js_cc_IDefineRecord_offset_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offset, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IDefineRecord_offset_set) + +static bool js_cc_IDefineRecord_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IDefineRecord *arg1 = (cc::IDefineRecord *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offset, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IDefineRecord_offset_get) + +static bool js_new_cc_IDefineRecord(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IDefineRecord *result; + result = (cc::IDefineRecord *)new cc::IDefineRecord(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IDefineRecord, __jsb_cc_IDefineRecord_class, js_delete_cc_IDefineRecord) + +static bool js_delete_cc_IDefineRecord(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IDefineRecord) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineRecord * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("map", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->map), ctx); + } + + + json->getProperty("offset", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->offset), ctx); + } + + + return ok; +} + + +bool js_register_cc_IDefineRecord(se::Object* obj) { + auto* cls = se::Class::create("IDefineRecord", obj, __jsb_cc_IDefineInfo_proto, _SE(js_new_cc_IDefineRecord)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("map", _SE(js_cc_IDefineRecord_map_get), _SE(js_cc_IDefineRecord_map_set)); + cls->defineProperty("offset", _SE(js_cc_IDefineRecord_offset_get), _SE(js_cc_IDefineRecord_offset_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IDefineRecord)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IDefineRecord_proto = cls->getProto(); + __jsb_cc_IDefineRecord_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IMacroInfo_class = nullptr; +se::Object* __jsb_cc_IMacroInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IMacroInfo) + +static bool js_cc_IMacroInfo_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMacroInfo_name_set) + +static bool js_cc_IMacroInfo_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMacroInfo_name_get) + +static bool js_cc_IMacroInfo_value_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->value, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMacroInfo_value_set) + +static bool js_cc_IMacroInfo_value_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->value, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->value, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMacroInfo_value_get) + +static bool js_cc_IMacroInfo_isDefault_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->isDefault); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IMacroInfo_isDefault_set) + +static bool js_cc_IMacroInfo_isDefault_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IMacroInfo *arg1 = (cc::IMacroInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->isDefault, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IMacroInfo_isDefault_get) + +static bool js_new_cc_IMacroInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IMacroInfo *result; + result = (cc::IMacroInfo *)new cc::IMacroInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IMacroInfo, __jsb_cc_IMacroInfo_class, js_delete_cc_IMacroInfo) + +static bool js_delete_cc_IMacroInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IMacroInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMacroInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->name), ctx); + } + + + json->getProperty("value", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->value), ctx); + } + + + json->getProperty("isDefault", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->isDefault), ctx); + } + + + return ok; +} + + +bool js_register_cc_IMacroInfo(se::Object* obj) { + auto* cls = se::Class::create("IMacroInfo", obj, nullptr, _SE(js_new_cc_IMacroInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_cc_IMacroInfo_name_get), _SE(js_cc_IMacroInfo_name_set)); + cls->defineProperty("value", _SE(js_cc_IMacroInfo_value_get), _SE(js_cc_IMacroInfo_value_set)); + cls->defineProperty("isDefault", _SE(js_cc_IMacroInfo_isDefault_get), _SE(js_cc_IMacroInfo_isDefault_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IMacroInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IMacroInfo_proto = cls->getProto(); + __jsb_cc_IMacroInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_IProgramInfo_class = nullptr; +se::Object* __jsb_cc_IProgramInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_IProgramInfo) + +static bool js_cc_IProgramInfo_effectName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->effectName, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_effectName_set) + +static bool js_cc_IProgramInfo_effectName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->effectName, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->effectName, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_effectName_get) + +static bool js_cc_IProgramInfo_defines_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->defines, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_defines_set) + +static bool js_cc_IProgramInfo_defines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->defines, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->defines, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_defines_get) + +static bool js_cc_IProgramInfo_constantMacros_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->constantMacros, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_constantMacros_set) + +static bool js_cc_IProgramInfo_constantMacros_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->constantMacros, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->constantMacros, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_constantMacros_get) + +static bool js_cc_IProgramInfo_uber_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uber); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_IProgramInfo_uber_set) + +static bool js_cc_IProgramInfo_uber_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uber, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_IProgramInfo_uber_get) + +static bool js_cc_IProgramInfo_copyFrom(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::IProgramInfo *arg1 = (cc::IProgramInfo *) NULL ; + cc::IShaderInfo *arg2 = 0 ; + cc::IShaderInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->copyFrom((cc::IShaderInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_IProgramInfo_copyFrom) + +static bool js_new_cc_IProgramInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::IProgramInfo *result; + result = (cc::IProgramInfo *)new cc::IProgramInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_IProgramInfo, __jsb_cc_IProgramInfo_class, js_delete_cc_IProgramInfo) + +static bool js_delete_cc_IProgramInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_IProgramInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::IProgramInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("effectName", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->effectName), ctx); + } + + + json->getProperty("defines", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->defines), ctx); + } + + + json->getProperty("constantMacros", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->constantMacros), ctx); + } + + + json->getProperty("uber", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->uber), ctx); + } + + + return ok; +} + + +bool js_register_cc_IProgramInfo(se::Object* obj) { + auto* cls = se::Class::create("IProgramInfo", obj, __jsb_cc_IShaderInfo_proto, _SE(js_new_cc_IProgramInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("effectName", _SE(js_cc_IProgramInfo_effectName_get), _SE(js_cc_IProgramInfo_effectName_set)); + cls->defineProperty("defines", _SE(js_cc_IProgramInfo_defines_get), _SE(js_cc_IProgramInfo_defines_set)); + cls->defineProperty("constantMacros", _SE(js_cc_IProgramInfo_constantMacros_get), _SE(js_cc_IProgramInfo_constantMacros_set)); + cls->defineProperty("uber", _SE(js_cc_IProgramInfo_uber_get), _SE(js_cc_IProgramInfo_uber_set)); + + cls->defineFunction("copyFrom", _SE(js_cc_IProgramInfo_copyFrom)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_IProgramInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_IProgramInfo_proto = cls->getProto(); + __jsb_cc_IProgramInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_cc_getDeviceShaderVersion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::gfx::Device *arg1 = (cc::gfx::Device *) NULL ; + char *result = 0 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (char *)cc::getDeviceShaderVersion((cc::gfx::Device const *)arg1); + + ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_FUNC(js_cc_getDeviceShaderVersion) + +se::Class* __jsb_cc_ProgramLib_class = nullptr; +se::Object* __jsb_cc_ProgramLib_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_ProgramLib) + +static bool js_cc_ProgramLib_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::ProgramLib *)cc::ProgramLib::getInstance(); + + 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_ProgramLib_getInstance_static) + +static bool js_new_cc_ProgramLib(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::ProgramLib *result; + result = (cc::ProgramLib *)new cc::ProgramLib(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_ProgramLib, __jsb_cc_ProgramLib_class, js_delete_cc_ProgramLib) + +static bool js_delete_cc_ProgramLib(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_ProgramLib) + +static bool js_cc_ProgramLib_cpp_keyword_register(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::EffectAsset *arg2 = (cc::EffectAsset *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->registerEffect(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_cpp_keyword_register) + +static bool js_cc_ProgramLib_define(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::IShaderInfo *arg2 = 0 ; + cc::IShaderInfo temp2 ; + cc::IProgramInfo *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(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::IProgramInfo *)(arg1)->define(*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_ProgramLib_define) + +static bool js_cc_ProgramLib_getTemplate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::IProgramInfo *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(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::IProgramInfo *)((cc::ProgramLib const *)arg1)->getTemplate((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_ProgramLib_getTemplate) + +static bool js_cc_ProgramLib_getTemplateInfo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + ccstd::string *arg2 = 0 ; + ccstd::string temp2 ; + cc::ITemplateInfo *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(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::ITemplateInfo *)(arg1)->getTemplateInfo((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_ProgramLib_getTemplateInfo) + +static bool js_cc_ProgramLib_getDescriptorSetLayout__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + bool arg4 ; + ccstd::string temp3 ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout(arg2,(ccstd::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getDescriptorSetLayout__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + ccstd::string temp3 ; + cc::gfx::DescriptorSetLayout *result = 0 ; + + arg1 = SE_THIS_OBJECT(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::gfx::DescriptorSetLayout *)(arg1)->getDescriptorSetLayout(arg2,(ccstd::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getDescriptorSetLayout(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_ProgramLib_getDescriptorSetLayout__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_ProgramLib_getDescriptorSetLayout__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_ProgramLib_getDescriptorSetLayout) + +static bool js_cc_ProgramLib_hasProgram(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) 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(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::ProgramLib const *)arg1)->hasProgram((ccstd::string const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_hasProgram) + +static bool js_cc_ProgramLib_getKey(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + ccstd::string *arg2 = 0 ; + cc::MacroRecord *arg3 = 0 ; + ccstd::string temp2 ; + cc::MacroRecord temp3 ; + ccstd::string result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (arg1)->getKey((ccstd::string const &)*arg2,(cc::MacroRecord const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_getKey) + +static bool js_cc_ProgramLib_destroyShaderByDefines(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::MacroRecord *arg2 = 0 ; + cc::MacroRecord temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->destroyShaderByDefines((cc::MacroRecord const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_ProgramLib_destroyShaderByDefines) + +static bool js_cc_ProgramLib_getGFXShader__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + cc::MacroRecord *arg4 = 0 ; + cc::render::PipelineRuntime *arg5 = (cc::render::PipelineRuntime *) NULL ; + ccstd::string *arg6 = (ccstd::string *) NULL ; + ccstd::string temp3 ; + cc::MacroRecord temp4 ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + 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 = (cc::gfx::Shader *)(arg1)->getGFXShader(arg2,(ccstd::string const &)*arg3,*arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getGFXShader__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::ProgramLib *arg1 = (cc::ProgramLib *) NULL ; + cc::gfx::Device *arg2 = (cc::gfx::Device *) NULL ; + ccstd::string *arg3 = 0 ; + cc::MacroRecord *arg4 = 0 ; + cc::render::PipelineRuntime *arg5 = (cc::render::PipelineRuntime *) NULL ; + ccstd::string temp3 ; + cc::MacroRecord temp4 ; + cc::gfx::Shader *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::gfx::Shader *)(arg1)->getGFXShader(arg2,(ccstd::string const &)*arg3,*arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_ProgramLib_getGFXShader(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 5) { + ok = js_cc_ProgramLib_getGFXShader__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_cc_ProgramLib_getGFXShader__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_ProgramLib_getGFXShader) + +bool js_register_cc_ProgramLib(se::Object* obj) { + auto* cls = se::Class::create("ProgramLib", obj, nullptr, _SE(js_new_cc_ProgramLib)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("register", _SE(js_cc_ProgramLib_cpp_keyword_register)); + cls->defineFunction("define", _SE(js_cc_ProgramLib_define)); + cls->defineFunction("getTemplate", _SE(js_cc_ProgramLib_getTemplate)); + cls->defineFunction("getTemplateInfo", _SE(js_cc_ProgramLib_getTemplateInfo)); + cls->defineFunction("getDescriptorSetLayout", _SE(js_cc_ProgramLib_getDescriptorSetLayout)); + cls->defineFunction("hasProgram", _SE(js_cc_ProgramLib_hasProgram)); + cls->defineFunction("getKey", _SE(js_cc_ProgramLib_getKey)); + cls->defineFunction("destroyShaderByDefines", _SE(js_cc_ProgramLib_destroyShaderByDefines)); + cls->defineFunction("getGFXShader", _SE(js_cc_ProgramLib_getGFXShader)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_ProgramLib_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_ProgramLib)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_ProgramLib_proto = cls->getProto(); + __jsb_cc_ProgramLib_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_OctreeInfo_class = nullptr; +se::Object* __jsb_cc_scene_OctreeInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_OctreeInfo) + +static bool js_new_cc_scene_OctreeInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::OctreeInfo *result; + result = (cc::scene::OctreeInfo *)new cc::scene::OctreeInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_OctreeInfo, __jsb_cc_scene_OctreeInfo_class, js_delete_cc_scene_OctreeInfo) + +static bool js_delete_cc_scene_OctreeInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_OctreeInfo) + +static bool js_cc_scene_OctreeInfo_activate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::scene::Octree *arg2 = (cc::scene::Octree *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->activate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_OctreeInfo_activate) + +static bool js_cc_scene_OctreeInfo__enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_enabled); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__enabled_set) + +static bool js_cc_scene_OctreeInfo__enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_enabled, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__enabled_get) + +static bool js_cc_scene_OctreeInfo__minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_minPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__minPos_set) + +static bool js_cc_scene_OctreeInfo__minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_minPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_minPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__minPos_get) + +static bool js_cc_scene_OctreeInfo__maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_maxPos, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__maxPos_set) + +static bool js_cc_scene_OctreeInfo__maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_maxPos, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_maxPos, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__maxPos_get) + +static bool js_cc_scene_OctreeInfo__depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_depth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo__depth_set) + +static bool js_cc_scene_OctreeInfo__depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_depth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo__depth_get) + +static bool js_cc_scene_OctreeInfo_enabled_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + cc_scene_OctreeInfo_enabled_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_enabled_set) + +static bool js_cc_scene_OctreeInfo_enabled_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)cc_scene_OctreeInfo_enabled_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo_enabled_get) + +static bool js_cc_scene_OctreeInfo_minPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_OctreeInfo_minPos_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_minPos_set) + +static bool js_cc_scene_OctreeInfo_minPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_OctreeInfo_minPos_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_scene_OctreeInfo_minPos_get) + +static bool js_cc_scene_OctreeInfo_maxPos_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + cc_scene_OctreeInfo_maxPos_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_maxPos_set) + +static bool js_cc_scene_OctreeInfo_maxPos_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + cc::Vec3 *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &cc_scene_OctreeInfo_maxPos_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_scene_OctreeInfo_maxPos_get) + +static bool js_cc_scene_OctreeInfo_depth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + uint32_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + cc_scene_OctreeInfo_depth_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_OctreeInfo_depth_set) + +static bool js_cc_scene_OctreeInfo_depth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::OctreeInfo *arg1 = (cc::scene::OctreeInfo *) NULL ; + uint32_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = cc_scene_OctreeInfo_depth_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_OctreeInfo_depth_get) + +bool js_register_cc_scene_OctreeInfo(se::Object* obj) { + auto* cls = se::Class::create("OctreeInfo", obj, nullptr, _SE(js_new_cc_scene_OctreeInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_enabled", _SE(js_cc_scene_OctreeInfo__enabled_get), _SE(js_cc_scene_OctreeInfo__enabled_set)); + cls->defineProperty("_minPos", _SE(js_cc_scene_OctreeInfo__minPos_get), _SE(js_cc_scene_OctreeInfo__minPos_set)); + cls->defineProperty("_maxPos", _SE(js_cc_scene_OctreeInfo__maxPos_get), _SE(js_cc_scene_OctreeInfo__maxPos_set)); + cls->defineProperty("_depth", _SE(js_cc_scene_OctreeInfo__depth_get), _SE(js_cc_scene_OctreeInfo__depth_set)); + cls->defineProperty("enabled", _SE(js_cc_scene_OctreeInfo_enabled_get), _SE(js_cc_scene_OctreeInfo_enabled_set)); + cls->defineProperty("minPos", _SE(js_cc_scene_OctreeInfo_minPos_get), _SE(js_cc_scene_OctreeInfo_minPos_set)); + cls->defineProperty("maxPos", _SE(js_cc_scene_OctreeInfo_maxPos_get), _SE(js_cc_scene_OctreeInfo_maxPos_set)); + cls->defineProperty("depth", _SE(js_cc_scene_OctreeInfo_depth_get), _SE(js_cc_scene_OctreeInfo_depth_set)); + + cls->defineFunction("activate", _SE(js_cc_scene_OctreeInfo_activate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_OctreeInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_OctreeInfo_proto = cls->getProto(); + __jsb_cc_scene_OctreeInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_BBox_class = nullptr; +se::Object* __jsb_cc_scene_BBox_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_BBox) + +static bool js_cc_scene_BBox_min_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->min, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_BBox_min_set) + +static bool js_cc_scene_BBox_min_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->min, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->min, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_BBox_min_get) + +static bool js_cc_scene_BBox_max_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->max, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_scene_BBox_max_set) + +static bool js_cc_scene_BBox_max_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->max, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->max, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_scene_BBox_max_get) + +static bool js_new_cc_scene_BBox__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::scene::BBox *result; + result = (cc::scene::BBox *)new cc::scene::BBox(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_BBox__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::geometry::AABB *arg1 = 0 ; + cc::geometry::AABB temp1 ; + cc::scene::BBox *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (cc::scene::BBox *)new cc::scene::BBox((cc::geometry::AABB const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_BBox__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::Vec3 *arg1 = 0 ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp1 ; + cc::Vec3 temp2 ; + cc::scene::BBox *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::scene::BBox *)new cc::scene::BBox((cc::Vec3 const &)*arg1,(cc::Vec3 const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_scene_BBox(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_scene_BBox__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_scene_BBox__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_scene_BBox__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of BBox"); + return false; +} +SE_BIND_CTOR(js_new_cc_scene_BBox, __jsb_cc_scene_BBox_class, js_delete_cc_scene_BBox) + +static bool js_cc_scene_BBox_getCenter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::Vec3 result; + cc::Vec3 *temp ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::BBox const *)arg1)->getCenter(); + + temp = ccnew cc::Vec3(result); + ok &= nativevalue_to_se(temp, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + s.rval().toObject()->getPrivateObject()->tryAllowDestroyInGC(); + + + + return true; +} +SE_BIND_FUNC(js_cc_scene_BBox_getCenter) + +static bool js_cc_scene_BBox_contain__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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::scene::BBox const *)arg1)->contain((cc::Vec3 const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_BBox_contain__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::scene::BBox *arg2 = 0 ; + cc::scene::BBox temp2 ; + bool result; + + arg1 = SE_THIS_OBJECT(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::scene::BBox const *)arg1)->contain((cc::scene::BBox const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_scene_BBox_contain(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_scene_BBox_contain__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_scene_BBox_contain__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_scene_BBox_contain) + +static bool js_cc_scene_BBox_intersect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::BBox *arg1 = (cc::scene::BBox *) NULL ; + cc::scene::BBox *arg2 = 0 ; + cc::scene::BBox 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(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::scene::BBox const *)arg1)->intersect((cc::scene::BBox const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_BBox_intersect) + +static bool js_delete_cc_scene_BBox(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_BBox) + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::BBox * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("min", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->min), ctx); + } + + + json->getProperty("max", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->max), ctx); + } + + + return ok; +} + + +bool js_register_cc_scene_BBox(se::Object* obj) { + auto* cls = se::Class::create("BBox", obj, nullptr, _SE(js_new_cc_scene_BBox)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("min", _SE(js_cc_scene_BBox_min_get), _SE(js_cc_scene_BBox_min_set)); + cls->defineProperty("max", _SE(js_cc_scene_BBox_max_get), _SE(js_cc_scene_BBox_max_set)); + + cls->defineFunction("getCenter", _SE(js_cc_scene_BBox_getCenter)); + cls->defineFunction("contain", _SE(js_cc_scene_BBox_contain)); + cls->defineFunction("intersect", _SE(js_cc_scene_BBox_intersect)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_BBox)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_BBox_proto = cls->getProto(); + __jsb_cc_scene_BBox_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_OctreeNode_class = nullptr; +se::Object* __jsb_cc_scene_OctreeNode_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_OctreeNode) + +bool js_register_cc_scene_OctreeNode(se::Object* obj) { + auto* cls = se::Class::create("OctreeNode", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_OctreeNode_proto = cls->getProto(); + __jsb_cc_scene_OctreeNode_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_scene_Octree_class = nullptr; +se::Object* __jsb_cc_scene_Octree_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_scene_Octree) + +static bool js_new_cc_scene_Octree(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::scene::Octree *result; + result = (cc::scene::Octree *)new cc::scene::Octree(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_scene_Octree, __jsb_cc_scene_Octree_class, js_delete_cc_scene_Octree) + +static bool js_delete_cc_scene_Octree(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_scene_Octree) + +static bool js_cc_scene_Octree_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::OctreeInfo *arg2 = 0 ; + cc::scene::OctreeInfo temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initialize((cc::scene::OctreeInfo const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_initialize) + +static bool js_cc_scene_Octree_setEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setEnabled) + +static bool js_cc_scene_Octree_isEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::scene::Octree const *)arg1)->isEnabled(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_isEnabled) + +static bool js_cc_scene_Octree_setMinPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMinPos((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setMinPos) + +static bool js_cc_scene_Octree_getMinPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::Octree const *)arg1)->getMinPos(); + + 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_scene_Octree_getMinPos) + +static bool js_cc_scene_Octree_setMaxPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setMaxPos((cc::Vec3 const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setMaxPos) + +static bool js_cc_scene_Octree_getMaxPos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *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(s); + if (nullptr == arg1) return true; + result = (cc::Vec3 *) &((cc::scene::Octree const *)arg1)->getMaxPos(); + + 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_scene_Octree_getMaxPos) + +static bool js_cc_scene_Octree_resize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::Vec3 *arg2 = 0 ; + cc::Vec3 *arg3 = 0 ; + uint32_t arg4 ; + cc::Vec3 temp2 ; + cc::Vec3 temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->resize((cc::Vec3 const &)*arg2,(cc::Vec3 const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_resize) + +static bool js_cc_scene_Octree_insert(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->insert(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_insert) + +static bool js_cc_scene_Octree_remove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->remove(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_remove) + +static bool js_cc_scene_Octree_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Model *arg2 = (cc::scene::Model *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_update) + +static bool js_cc_scene_Octree_setMaxDepth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + uint32_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setMaxDepth(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_setMaxDepth) + +static bool js_cc_scene_Octree_getMaxDepth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + uint32_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::scene::Octree const *)arg1)->getMaxDepth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_getMaxDepth) + +static bool js_cc_scene_Octree_queryVisibility(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::scene::Octree *arg1 = (cc::scene::Octree *) NULL ; + cc::scene::Camera *arg2 = (cc::scene::Camera *) NULL ; + cc::geometry::Frustum *arg3 = 0 ; + bool arg4 ; + ccstd::vector< cc::scene::Model const * > *arg5 = 0 ; + cc::geometry::Frustum temp3 ; + ccstd::vector< cc::scene::Model const * > temp5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + ((cc::scene::Octree const *)arg1)->queryVisibility((cc::scene::Camera const *)arg2,(cc::geometry::Frustum const &)*arg3,arg4,*arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_scene_Octree_queryVisibility) + +bool js_register_cc_scene_Octree(se::Object* obj) { + auto* cls = se::Class::create("Octree", obj, nullptr, _SE(js_new_cc_scene_Octree)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initialize", _SE(js_cc_scene_Octree_initialize)); + cls->defineFunction("setEnabled", _SE(js_cc_scene_Octree_setEnabled)); + cls->defineFunction("isEnabled", _SE(js_cc_scene_Octree_isEnabled)); + cls->defineFunction("setMinPos", _SE(js_cc_scene_Octree_setMinPos)); + cls->defineFunction("getMinPos", _SE(js_cc_scene_Octree_getMinPos)); + cls->defineFunction("setMaxPos", _SE(js_cc_scene_Octree_setMaxPos)); + cls->defineFunction("getMaxPos", _SE(js_cc_scene_Octree_getMaxPos)); + cls->defineFunction("resize", _SE(js_cc_scene_Octree_resize)); + cls->defineFunction("insert", _SE(js_cc_scene_Octree_insert)); + cls->defineFunction("remove", _SE(js_cc_scene_Octree_remove)); + cls->defineFunction("update", _SE(js_cc_scene_Octree_update)); + cls->defineFunction("setMaxDepth", _SE(js_cc_scene_Octree_setMaxDepth)); + cls->defineFunction("getMaxDepth", _SE(js_cc_scene_Octree_getMaxDepth)); + cls->defineFunction("queryVisibility", _SE(js_cc_scene_Octree_queryVisibility)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_scene_Octree)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_scene_Octree_proto = cls->getProto(); + __jsb_cc_scene_Octree_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_scene(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("jsb", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("jsb", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_cc_Layers(ns); + js_register_cc_Node(ns); + js_register_cc_Node_UserData(ns); + js_register_cc_Scene(ns); + js_register_cc_SceneGlobals(ns); + js_register_cc_Root(ns); + js_register_cc_scene_IMacroPatch(ns); + js_register_cc_scene_Light(ns); + js_register_cc_scene_LODData(ns); + js_register_cc_scene_LODGroup(ns); + js_register_cc_scene_Fog(ns); + js_register_cc_scene_FogInfo(ns); + js_register_cc_scene_ShadowsInfo(ns); + js_register_cc_scene_Shadows(ns); + js_register_cc_scene_SkyboxInfo(ns); + js_register_cc_scene_Skybox(ns); + js_register_cc_scene_SkinInfo(ns); + js_register_cc_scene_Skin(ns); + js_register_cc_scene_PostSettingsInfo(ns); + js_register_cc_scene_PostSettings(ns); + js_register_cc_scene_DirectionalLight(ns); + js_register_cc_scene_SpotLight(ns); + js_register_cc_scene_SphereLight(ns); + js_register_cc_scene_PointLight(ns); + js_register_cc_scene_RangedDirectionalLight(ns); + js_register_cc_scene_Model(ns); + js_register_cc_scene_InstancedAttributeBlock(ns); + js_register_cc_scene_SubModel(ns); + js_register_cc_scene_PassDynamicsValue(ns); + js_register_cc_scene_IBlockRef(ns); + js_register_cc_scene_Pass(ns); + js_register_cc_scene_IRaycastResult(ns); + js_register_cc_scene_IRenderSceneInfo(ns); + js_register_cc_scene_RenderScene(ns); + js_register_cc_scene_IRenderWindowInfo(ns); + js_register_cc_scene_RenderWindow(ns); + js_register_cc_scene_ICameraInfo(ns); + js_register_cc_scene_Camera(ns); + js_register_cc_scene_Ambient(ns); + js_register_cc_scene_AmbientInfo(ns); + js_register_cc_scene_ReflectionProbe(ns); + js_register_cc_PassInstance(ns); + js_register_cc_IMaterialInstanceInfo(ns); + js_register_cc_MaterialInstance(ns); + js_register_cc_MorphModel(ns); + js_register_cc_SkinningModel(ns); + js_register_cc_BakedSkinningModel(ns); + js_register_cc_IDefineRecord(ns); + js_register_cc_IMacroInfo(ns); + js_register_cc_IProgramInfo(ns); + js_register_cc_ProgramLib(ns); + js_register_cc_scene_OctreeInfo(ns); + js_register_cc_scene_BBox(ns); + js_register_cc_scene_OctreeNode(ns); + js_register_cc_scene_Octree(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_scene_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_scene_auto.h new file mode 100644 index 0000000000..060b676852 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_scene_auto.h @@ -0,0 +1,404 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/auto/jsb_gi_auto.h" +#include "core/Root.h" +#include "core/scene-graph/Node.h" +#include "core/scene-graph/Scene.h" +#include "core/scene-graph/SceneGlobals.h" +#include "scene/Light.h" +#include "scene/LODGroup.h" +#include "scene/Fog.h" +#include "scene/Shadow.h" +#include "scene/Skybox.h" +#include "scene/Skin.h" +#include "scene/PostSettings.h" +#include "scene/DirectionalLight.h" +#include "scene/SpotLight.h" +#include "scene/SphereLight.h" +#include "scene/PointLight.h" +#include "scene/RangedDirectionalLight.h" +#include "scene/Model.h" +#include "scene/SubModel.h" +#include "scene/Pass.h" +#include "scene/RenderScene.h" +#include "scene/DrawBatch2D.h" +#include "scene/RenderWindow.h" +#include "scene/Camera.h" +#include "scene/Define.h" +#include "scene/Ambient.h" +#include "renderer/core/PassInstance.h" +#include "renderer/core/MaterialInstance.h" +#include "3d/models/MorphModel.h" +#include "3d/models/SkinningModel.h" +#include "3d/models/BakedSkinningModel.h" +#include "renderer/core/ProgramLib.h" +#include "scene/Octree.h" +#include "scene/ReflectionProbe.h" + + + +bool register_all_scene(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(cc::Layers); +extern se::Object *__jsb_cc_Layers_proto; // NOLINT +extern se::Class * __jsb_cc_Layers_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Node::UserData); +extern se::Object *__jsb_cc_Node_UserData_proto; // NOLINT +extern se::Class * __jsb_cc_Node_UserData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Node); +extern se::Object *__jsb_cc_Node_proto; // NOLINT +extern se::Class * __jsb_cc_Node_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Scene); +extern se::Object *__jsb_cc_Scene_proto; // NOLINT +extern se::Class * __jsb_cc_Scene_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SceneGlobals); +extern se::Object *__jsb_cc_SceneGlobals_proto; // NOLINT +extern se::Class * __jsb_cc_SceneGlobals_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::Root); +extern se::Object *__jsb_cc_Root_proto; // NOLINT +extern se::Class * __jsb_cc_Root_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IMacroPatch); +extern se::Object *__jsb_cc_scene_IMacroPatch_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IMacroPatch_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IMacroPatch * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Light); +extern se::Object *__jsb_cc_scene_Light_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Light_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::LODData); +extern se::Object *__jsb_cc_scene_LODData_proto; // NOLINT +extern se::Class * __jsb_cc_scene_LODData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::LODGroup); +extern se::Object *__jsb_cc_scene_LODGroup_proto; // NOLINT +extern se::Class * __jsb_cc_scene_LODGroup_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Fog); +extern se::Object *__jsb_cc_scene_Fog_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Fog_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::FogInfo); +extern se::Object *__jsb_cc_scene_FogInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_FogInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::ShadowsInfo); +extern se::Object *__jsb_cc_scene_ShadowsInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_ShadowsInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Shadows); +extern se::Object *__jsb_cc_scene_Shadows_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Shadows_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SkyboxInfo); +extern se::Object *__jsb_cc_scene_SkyboxInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SkyboxInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Skybox); +extern se::Object *__jsb_cc_scene_Skybox_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Skybox_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SkinInfo); +extern se::Object *__jsb_cc_scene_SkinInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SkinInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Skin); +extern se::Object *__jsb_cc_scene_Skin_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Skin_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PostSettingsInfo); +extern se::Object *__jsb_cc_scene_PostSettingsInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PostSettingsInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PostSettings); +extern se::Object *__jsb_cc_scene_PostSettings_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PostSettings_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::DirectionalLight); +extern se::Object *__jsb_cc_scene_DirectionalLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_DirectionalLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SpotLight); +extern se::Object *__jsb_cc_scene_SpotLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SpotLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SphereLight); +extern se::Object *__jsb_cc_scene_SphereLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SphereLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PointLight); +extern se::Object *__jsb_cc_scene_PointLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PointLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::RangedDirectionalLight); +extern se::Object *__jsb_cc_scene_RangedDirectionalLight_proto; // NOLINT +extern se::Class * __jsb_cc_scene_RangedDirectionalLight_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Model); +extern se::Object *__jsb_cc_scene_Model_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Model_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::InstancedAttributeBlock); +extern se::Object *__jsb_cc_scene_InstancedAttributeBlock_proto; // NOLINT +extern se::Class * __jsb_cc_scene_InstancedAttributeBlock_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::InstancedAttributeBlock * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::SubModel); +extern se::Object *__jsb_cc_scene_SubModel_proto; // NOLINT +extern se::Class * __jsb_cc_scene_SubModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::PassDynamicsValue); +extern se::Object *__jsb_cc_scene_PassDynamicsValue_proto; // NOLINT +extern se::Class * __jsb_cc_scene_PassDynamicsValue_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::PassDynamicsValue * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IBlockRef); +extern se::Object *__jsb_cc_scene_IBlockRef_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IBlockRef_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IBlockRef * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Pass); +extern se::Object *__jsb_cc_scene_Pass_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Pass_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IRaycastResult); +extern se::Object *__jsb_cc_scene_IRaycastResult_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IRaycastResult_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRaycastResult * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IRenderSceneInfo); +extern se::Object *__jsb_cc_scene_IRenderSceneInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IRenderSceneInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderSceneInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::RenderScene); +extern se::Object *__jsb_cc_scene_RenderScene_proto; // NOLINT +extern se::Class * __jsb_cc_scene_RenderScene_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::IRenderWindowInfo); +extern se::Object *__jsb_cc_scene_IRenderWindowInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_IRenderWindowInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::IRenderWindowInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::RenderWindow); +extern se::Object *__jsb_cc_scene_RenderWindow_proto; // NOLINT +extern se::Class * __jsb_cc_scene_RenderWindow_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::ICameraInfo); +extern se::Object *__jsb_cc_scene_ICameraInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_ICameraInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::ICameraInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Camera); +extern se::Object *__jsb_cc_scene_Camera_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Camera_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Ambient); +extern se::Object *__jsb_cc_scene_Ambient_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Ambient_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::AmbientInfo); +extern se::Object *__jsb_cc_scene_AmbientInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_AmbientInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::ReflectionProbe); +extern se::Object *__jsb_cc_scene_ReflectionProbe_proto; // NOLINT +extern se::Class * __jsb_cc_scene_ReflectionProbe_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::PassInstance); +extern se::Object *__jsb_cc_PassInstance_proto; // NOLINT +extern se::Class * __jsb_cc_PassInstance_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IMaterialInstanceInfo); +extern se::Object *__jsb_cc_IMaterialInstanceInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IMaterialInstanceInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMaterialInstanceInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::MaterialInstance); +extern se::Object *__jsb_cc_MaterialInstance_proto; // NOLINT +extern se::Class * __jsb_cc_MaterialInstance_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::MorphModel); +extern se::Object *__jsb_cc_MorphModel_proto; // NOLINT +extern se::Class * __jsb_cc_MorphModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkinningModel); +extern se::Object *__jsb_cc_SkinningModel_proto; // NOLINT +extern se::Class * __jsb_cc_SkinningModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::BakedSkinningModel); +extern se::Object *__jsb_cc_BakedSkinningModel_proto; // NOLINT +extern se::Class * __jsb_cc_BakedSkinningModel_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::IDefineRecord); +extern se::Object *__jsb_cc_IDefineRecord_proto; // NOLINT +extern se::Class * __jsb_cc_IDefineRecord_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IDefineRecord * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IMacroInfo); +extern se::Object *__jsb_cc_IMacroInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IMacroInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IMacroInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::IProgramInfo); +extern se::Object *__jsb_cc_IProgramInfo_proto; // NOLINT +extern se::Class * __jsb_cc_IProgramInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::IProgramInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::ProgramLib); +extern se::Object *__jsb_cc_ProgramLib_proto; // NOLINT +extern se::Class * __jsb_cc_ProgramLib_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::OctreeInfo); +extern se::Object *__jsb_cc_scene_OctreeInfo_proto; // NOLINT +extern se::Class * __jsb_cc_scene_OctreeInfo_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::BBox); +extern se::Object *__jsb_cc_scene_BBox_proto; // NOLINT +extern se::Class * __jsb_cc_scene_BBox_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::scene::BBox * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::OctreeNode); +extern se::Object *__jsb_cc_scene_OctreeNode_proto; // NOLINT +extern se::Class * __jsb_cc_scene_OctreeNode_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::scene::Octree); +extern se::Object *__jsb_cc_scene_Octree_proto; // NOLINT +extern se::Class * __jsb_cc_scene_Octree_class; // NOLINT + +// clang-format on diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_spine_3_8_auto.cpp b/native/build_android/generated/cocos/bindings/auto/temp/jsb_spine_3_8_auto.cpp new file mode 100644 index 0000000000..cba78d861b --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_spine_3_8_auto.cpp @@ -0,0 +1,25751 @@ +// 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 + + +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "bindings/manual/jsb_global.h" + + +#include "bindings/auto/jsb_2d_auto.h" +#include "bindings/auto/jsb_assets_auto.h" +#include "bindings/auto/jsb_cocos_auto.h" +#include "bindings/auto/jsb_spine_3_8_auto.h" +using namespace spine; + +#define SWIGINTERN static + + +#define spine_Animation_name_get(self_) self_->getName() + + +#define spine_Animation_timelines_get(self_) self_->getTimelines() + + +#define spine_Animation_duration_get(self_) self_->getDuration() +#define spine_Animation_duration_set(self_, val_) self_->setDuration(val_) + + +#define spine_RotateTimeline_boneIndex_get(self_) self_->getBoneIndex() +#define spine_RotateTimeline_boneIndex_set(self_, val_) self_->setBoneIndex(val_) + + +#define spine_RotateTimeline_frames_get(self_) self_->getFrames() + + +#define spine_ColorTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_ColorTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_ColorTimeline_frames_get(self_) self_->getFrames() + + +#define spine_TwoColorTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_TwoColorTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_AttachmentTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_AttachmentTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_AttachmentTimeline_frames_get(self_) self_->getFrames() + + +#define spine_AttachmentTimeline_attachmentNames_get(self_) self_->getAttachmentNames() + + +#define spine_DeformTimeline_slotIndex_get(self_) self_->getSlotIndex() +#define spine_DeformTimeline_slotIndex_set(self_, val_) self_->setSlotIndex(val_) + + +#define spine_DeformTimeline_frames_get(self_) self_->getFrames() + + +#define spine_DeformTimeline_frameVertices_get(self_) self_->getVertices() + + +#define spine_DeformTimeline_attachment_get(self_) self_->getAttachment() + + +#define spine_EventTimeline_frames_get(self_) self_->getFrames() + + +#define spine_EventTimeline_events_get(self_) self_->getEvents() + + +#define spine_DrawOrderTimeline_frames_get(self_) self_->getFrames() + + +#define spine_DrawOrderTimeline_drawOrders_get(self_) self_->getDrawOrders() + + +#define spine_AnimationState_data_get(self_) self_->getData() + + +#define spine_AnimationState_tracks_get(self_) self_->getTracks() + + +#define spine_AnimationState_timeScale_get(self_) self_->getTimeScale() +#define spine_AnimationState_timeScale_set(self_, val_) self_->setTimeScale(val_) + + +#define spine_TrackEntry_animation_get(self_) self_->getAnimation() + + +#define spine_TrackEntry_next_get(self_) self_->getNext() + + +#define spine_TrackEntry_mixingFrom_get(self_) self_->getMixingFrom() + + +#define spine_TrackEntry_mixingTo_get(self_) self_->getMixingTo() + + +#define spine_TrackEntry_trackIndex_get(self_) self_->getTrackIndex() + + +#define spine_TrackEntry_loop_get(self_) self_->getLoop() +#define spine_TrackEntry_loop_set(self_, val_) self_->setLoop(val_) + + +#define spine_TrackEntry_holdPrevious_get(self_) self_->getHoldPrevious() +#define spine_TrackEntry_holdPrevious_set(self_, val_) self_->setHoldPrevious(val_) + + +#define spine_TrackEntry_eventThreshold_get(self_) self_->getEventThreshold() +#define spine_TrackEntry_eventThreshold_set(self_, val_) self_->setEventThreshold(val_) + + +#define spine_TrackEntry_attachmentThreshold_get(self_) self_->getAttachmentThreshold() +#define spine_TrackEntry_attachmentThreshold_set(self_, val_) self_->setAttachmentThreshold(val_) + + +#define spine_TrackEntry_drawOrderThreshold_get(self_) self_->getDrawOrderThreshold() +#define spine_TrackEntry_drawOrderThreshold_set(self_, val_) self_->setDrawOrderThreshold(val_) + + +#define spine_TrackEntry_animationStart_get(self_) self_->getAnimationStart() +#define spine_TrackEntry_animationStart_set(self_, val_) self_->setAnimationStart(val_) + + +#define spine_TrackEntry_animationEnd_get(self_) self_->getAnimationEnd() +#define spine_TrackEntry_animationEnd_set(self_, val_) self_->setAnimationEnd(val_) + + +#define spine_TrackEntry_animationLast_get(self_) self_->getAnimationLast() +#define spine_TrackEntry_animationLast_set(self_, val_) self_->setAnimationLast(val_) + + +#define spine_TrackEntry_delay_get(self_) self_->getDelay() +#define spine_TrackEntry_delay_set(self_, val_) self_->setDelay(val_) + + +#define spine_TrackEntry_trackTime_get(self_) self_->getTrackTime() +#define spine_TrackEntry_trackTime_set(self_, val_) self_->setTrackTime(val_) + + +#define spine_TrackEntry_trackEnd_get(self_) self_->getTrackEnd() +#define spine_TrackEntry_trackEnd_set(self_, val_) self_->setTrackEnd(val_) + + +#define spine_TrackEntry_timeScale_get(self_) self_->getTimeScale() +#define spine_TrackEntry_timeScale_set(self_, val_) self_->setTimeScale(val_) + + +#define spine_TrackEntry_alpha_get(self_) self_->getAlpha() +#define spine_TrackEntry_alpha_set(self_, val_) self_->setAlpha(val_) + + +#define spine_TrackEntry_mixTime_get(self_) self_->getMixTime() +#define spine_TrackEntry_mixTime_set(self_, val_) self_->setMixTime(val_) + + +#define spine_TrackEntry_mixDuration_get(self_) self_->getMixDuration() +#define spine_TrackEntry_mixDuration_set(self_, val_) self_->setMixDuration(val_) + + +#define spine_TrackEntry_mixBlend_get(self_) self_->getMixBlend() +#define spine_TrackEntry_mixBlend_set(self_, val_) self_->setMixBlend(val_) + + +#define spine_AnimationStateData_skeletonData_get(self_) self_->getSkeletonData() + + +#define spine_AnimationStateData_defaultMix_get(self_) self_->getDefaultMix() +#define spine_AnimationStateData_defaultMix_set(self_, val_) self_->setDefaultMix(val_) + + +#define spine_Bone_data_get(self_) self_->getData() + + +#define spine_Bone_skeleton_get(self_) self_->getSkeleton() + + +#define spine_Bone_parent_get(self_) self_->getParent() + + +#define spine_Bone_children_get(self_) self_->getChildren() + + +#define spine_Bone_x_get(self_) self_->getX() +#define spine_Bone_x_set(self_, val_) self_->setX(val_) + + +#define spine_Bone_y_get(self_) self_->getY() +#define spine_Bone_y_set(self_, val_) self_->setY(val_) + + +#define spine_Bone_rotation_get(self_) self_->getRotation() +#define spine_Bone_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_Bone_scaleX_get(self_) self_->getScaleX() +#define spine_Bone_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_Bone_scaleY_get(self_) self_->getScaleY() +#define spine_Bone_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_Bone_shearX_get(self_) self_->getShearX() +#define spine_Bone_shearX_set(self_, val_) self_->setShearX(val_) + + +#define spine_Bone_shearY_get(self_) self_->getShearY() +#define spine_Bone_shearY_set(self_, val_) self_->setShearY(val_) + + +#define spine_Bone_ax_get(self_) self_->getAX() +#define spine_Bone_ax_set(self_, val_) self_->setAX(val_) + + +#define spine_Bone_ay_get(self_) self_->getAY() +#define spine_Bone_ay_set(self_, val_) self_->setAY(val_) + + +#define spine_Bone_arotation_get(self_) self_->getAppliedRotation() +#define spine_Bone_arotation_set(self_, val_) self_->setAppliedRotation(val_) + + +#define spine_Bone_ascaleX_get(self_) self_->getAScaleX() +#define spine_Bone_ascaleX_set(self_, val_) self_->setAScaleX(val_) + + +#define spine_Bone_ascaleY_get(self_) self_->getAScaleY() +#define spine_Bone_ascaleY_set(self_, val_) self_->setAScaleY(val_) + + +#define spine_Bone_ashearX_get(self_) self_->getAShearX() +#define spine_Bone_ashearX_set(self_, val_) self_->setAShearX(val_) + + +#define spine_Bone_ashearY_get(self_) self_->getAShearY() +#define spine_Bone_ashearY_set(self_, val_) self_->setAShearY(val_) + + +#define spine_Bone_appliedValid_get(self_) self_->isAppliedValid() +#define spine_Bone_appliedValid_set(self_, val_) self_->setAppliedValid(val_) + + +#define spine_Bone_a_get(self_) self_->getA() +#define spine_Bone_a_set(self_, val_) self_->setA(val_) + + +#define spine_Bone_b_get(self_) self_->getB() +#define spine_Bone_b_set(self_, val_) self_->setB(val_) + + +#define spine_Bone_c_get(self_) self_->getC() +#define spine_Bone_c_set(self_, val_) self_->setC(val_) + + +#define spine_Bone_d_get(self_) self_->getD() +#define spine_Bone_d_set(self_, val_) self_->setD(val_) + + +#define spine_Bone_worldX_get(self_) self_->getWorldX() +#define spine_Bone_worldX_set(self_, val_) self_->setWorldX(val_) + + +#define spine_Bone_worldY_get(self_) self_->getWorldY() +#define spine_Bone_worldY_set(self_, val_) self_->setWorldY(val_) + + +#define spine_Bone_active_get(self_) self_->isActive() +#define spine_Bone_active_set(self_, val_) self_->setActive(val_) + + +#define spine_BoneData_index_get(self_) self_->getIndex() + + +#define spine_BoneData_name_get(self_) self_->getName() + + +#define spine_BoneData_parent_get(self_) self_->getParent() + + +#define spine_BoneData_length_get(self_) self_->getLength() +#define spine_BoneData_length_set(self_, val_) self_->setLength(val_) + + +#define spine_BoneData_x_get(self_) self_->getX() +#define spine_BoneData_x_set(self_, val_) self_->setX(val_) + + +#define spine_BoneData_y_get(self_) self_->getY() +#define spine_BoneData_y_set(self_, val_) self_->setY(val_) + + +#define spine_BoneData_rotation_get(self_) self_->getRotation() +#define spine_BoneData_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_BoneData_scaleX_get(self_) self_->getScaleX() +#define spine_BoneData_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_BoneData_scaleY_get(self_) self_->getScaleY() +#define spine_BoneData_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_BoneData_shearX_get(self_) self_->getShearX() +#define spine_BoneData_shearX_set(self_, val_) self_->setShearX(val_) + + +#define spine_BoneData_shearY_get(self_) self_->getShearY() +#define spine_BoneData_shearY_set(self_, val_) self_->setShearY(val_) + + +#define spine_BoneData_transformMode_get(self_) self_->getTransformMode() +#define spine_BoneData_transformMode_set(self_, val_) self_->setTransformMode(val_) + + +#define spine_BoneData_skinRequired_get(self_) self_->isSkinRequired() +#define spine_BoneData_skinRequired_set(self_, val_) self_->setSkinRequired(val_) + + +#define spine_ConstraintData_name_get(self_) self_->getName() + + +#define spine_ConstraintData_order_get(self_) self_->getOrder() +#define spine_ConstraintData_order_set(self_, val_) self_->setOrder(val_) + + +#define spine_ConstraintData_skinRequired_get(self_) self_->isSkinRequired() +#define spine_ConstraintData_skinRequired_set(self_, val_) self_->setSkinRequired(val_) + + +#define spine_Event_data_get(self_) self_->getData() + + +#define spine_Event_intValue_get(self_) self_->getIntValue() +#define spine_Event_intValue_set(self_, val_) self_->setIntValue(val_) + + +#define spine_Event_floatValue_get(self_) self_->getFloatValue() +#define spine_Event_floatValue_set(self_, val_) self_->setFloatValue(val_) + + +#define spine_Event_stringValue_get(self_) self_->getStringValue() +#define spine_Event_stringValue_set(self_, val_) self_->setStringValue(val_) + + +#define spine_Event_time_get(self_) self_->getTime() + + +#define spine_Event_volume_get(self_) self_->getVolume() +#define spine_Event_volume_set(self_, val_) self_->setVolume(val_) + + +#define spine_Event_balance_get(self_) self_->getBalance() +#define spine_Event_balance_set(self_, val_) self_->setBalance(val_) + + +#define spine_EventData_name_get(self_) self_->getName() + + +#define spine_EventData_intValue_get(self_) self_->getIntValue() +#define spine_EventData_intValue_set(self_, val_) self_->setIntValue(val_) + + +#define spine_EventData_floatValue_get(self_) self_->getFloatValue() +#define spine_EventData_floatValue_set(self_, val_) self_->setFloatValue(val_) + + +#define spine_EventData_stringValue_get(self_) self_->getStringValue() +#define spine_EventData_stringValue_set(self_, val_) self_->setStringValue(val_) + + +#define spine_EventData_volume_get(self_) self_->getVolume() +#define spine_EventData_volume_set(self_, val_) self_->setVolume(val_) + + +#define spine_EventData_balance_get(self_) self_->getBalance() +#define spine_EventData_balance_set(self_, val_) self_->setBalance(val_) + + +#define spine_EventData_audioPath_get(self_) self_->getAudioPath() +#define spine_EventData_audioPath_set(self_, val_) self_->setAudioPath(val_) + + +#define spine_IkConstraint_data_get(self_) self_->getData() + + +#define spine_IkConstraint_bones_get(self_) self_->getBones() + + +#define spine_IkConstraint_target_get(self_) self_->getTarget() +#define spine_IkConstraint_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_IkConstraint_bendDirection_get(self_) self_->getBendDirection() +#define spine_IkConstraint_bendDirection_set(self_, val_) self_->setBendDirection(val_) + + +#define spine_IkConstraint_compress_get(self_) self_->getCompress() +#define spine_IkConstraint_compress_set(self_, val_) self_->setCompress(val_) + + +#define spine_IkConstraint_stretch_get(self_) self_->getStretch() +#define spine_IkConstraint_stretch_set(self_, val_) self_->setStretch(val_) + + +#define spine_IkConstraint_mix_get(self_) self_->getMix() +#define spine_IkConstraint_mix_set(self_, val_) self_->setMix(val_) + + +#define spine_IkConstraint_softness_get(self_) self_->getSoftness() +#define spine_IkConstraint_softness_set(self_, val_) self_->setSoftness(val_) + + +#define spine_IkConstraint_active_get(self_) self_->isActive() +#define spine_IkConstraint_active_set(self_, val_) self_->setActive(val_) + + +#define spine_IkConstraintData_bones_get(self_) self_->getBones() + + +#define spine_IkConstraintData_target_get(self_) self_->getTarget() + + +#define spine_IkConstraintData_bendDirection_get(self_) self_->getBendDirection() +#define spine_IkConstraintData_bendDirection_set(self_, val_) self_->setBendDirection(val_) + + +#define spine_IkConstraintData_compress_get(self_) self_->getCompress() +#define spine_IkConstraintData_compress_set(self_, val_) self_->setCompress(val_) + + +#define spine_IkConstraintData_stretch_get(self_) self_->getStretch() +#define spine_IkConstraintData_stretch_set(self_, val_) self_->setStretch(val_) + + +#define spine_IkConstraintData_uniform_get(self_) self_->getUniform() +#define spine_IkConstraintData_uniform_set(self_, val_) self_->setUniform(val_) + + +#define spine_IkConstraintData_mix_get(self_) self_->getMix() +#define spine_IkConstraintData_mix_set(self_, val_) self_->setMix(val_) + + +#define spine_IkConstraintData_softness_get(self_) self_->getSoftness() +#define spine_IkConstraintData_softness_set(self_, val_) self_->setSoftness(val_) + + +#define spine_PathConstraint_data_get(self_) self_->getData() + + +#define spine_PathConstraint_bones_get(self_) self_->getBones() + + +#define spine_PathConstraint_target_get(self_) self_->getTarget() +#define spine_PathConstraint_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_PathConstraint_position_get(self_) self_->getPosition() +#define spine_PathConstraint_position_set(self_, val_) self_->setPosition(val_) + + +#define spine_PathConstraint_spacing_get(self_) self_->getSpacing() +#define spine_PathConstraint_spacing_set(self_, val_) self_->setSpacing(val_) + + +#define spine_PathConstraint_rotateMix_get(self_) self_->getRotateMix() +#define spine_PathConstraint_rotateMix_set(self_, val_) self_->setRotateMix(val_) + + +#define spine_PathConstraint_translateMix_get(self_) self_->getTranslateMix() +#define spine_PathConstraint_translateMix_set(self_, val_) self_->setTranslateMix(val_) + + +#define spine_PathConstraint_active_get(self_) self_->isActive() +#define spine_PathConstraint_active_set(self_, val_) self_->setActive(val_) + + +#define spine_PathConstraintData_bones_get(self_) self_->getBones() + + +#define spine_PathConstraintData_target_get(self_) self_->getTarget() +#define spine_PathConstraintData_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_PathConstraintData_positionMode_get(self_) self_->getPositionMode() +#define spine_PathConstraintData_positionMode_set(self_, val_) self_->setPositionMode(val_) + + +#define spine_PathConstraintData_spacingMode_get(self_) self_->getSpacingMode() +#define spine_PathConstraintData_spacingMode_set(self_, val_) self_->setSpacingMode(val_) + + +#define spine_PathConstraintData_rotateMode_get(self_) self_->getRotateMode() +#define spine_PathConstraintData_rotateMode_set(self_, val_) self_->setRotateMode(val_) + + +#define spine_PathConstraintData_offsetRotation_get(self_) self_->getOffsetRotation() +#define spine_PathConstraintData_offsetRotation_set(self_, val_) self_->setOffsetRotation(val_) + + +#define spine_PathConstraintData_position_get(self_) self_->getPosition() +#define spine_PathConstraintData_position_set(self_, val_) self_->setPosition(val_) + + +#define spine_PathConstraintData_spacing_get(self_) self_->getSpacing() +#define spine_PathConstraintData_spacing_set(self_, val_) self_->setSpacing(val_) + + +#define spine_PathConstraintData_rotateMix_get(self_) self_->getRotateMix() +#define spine_PathConstraintData_rotateMix_set(self_, val_) self_->setRotateMix(val_) + + +#define spine_PathConstraintData_translateMix_get(self_) self_->getTranslateMix() +#define spine_PathConstraintData_translateMix_set(self_, val_) self_->setTranslateMix(val_) + + +#define spine_Skeleton_data_get(self_) self_->getData() + + +#define spine_Skeleton_bones_get(self_) self_->getBones() + + +#define spine_Skeleton_slots_get(self_) self_->getSlots() + + +#define spine_Skeleton_drawOrder_get(self_) self_->getDrawOrder() + + +#define spine_Skeleton_ikConstraints_get(self_) self_->getIkConstraints() + + +#define spine_Skeleton_transformConstraints_get(self_) self_->getTransformConstraints() + + +#define spine_Skeleton_pathConstraints_get(self_) self_->getPathConstraints() + + +#define spine_Skeleton__updateCache_get(self_) self_->getUpdateCacheList() + + +#define spine_Skeleton_skin_get(self_) self_->getSkin() +#define spine_Skeleton_skin_set(self_, val_) self_->setSkin(val_) + + +#define spine_Skeleton_color_get(self_) self_->getColor() + + +#define spine_Skeleton_time_get(self_) self_->getTime() +#define spine_Skeleton_time_set(self_, val_) self_->setTime(val_) + + +#define spine_Skeleton_scaleX_get(self_) self_->getScaleX() +#define spine_Skeleton_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_Skeleton_scaleY_get(self_) self_->getScaleY() +#define spine_Skeleton_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_Skeleton_x_get(self_) self_->getX() +#define spine_Skeleton_x_set(self_, val_) self_->setX(val_) + + +#define spine_Skeleton_y_get(self_) self_->getY() +#define spine_Skeleton_y_set(self_, val_) self_->setY(val_) + + +#define spine_SkeletonBinary_scale_set(self_, val_) self_->setScale(val_) + + +#define spine_SkeletonClipping_clippedVertices_get(self_) self_->getClippedVertices() + + +#define spine_SkeletonClipping_clippedTriangles_get(self_) self_->getClippedTriangles() + + +#define spine_SkeletonData_name_get(self_) self_->getName() +#define spine_SkeletonData_name_set(self_, val_) self_->setName(val_) + + +#define spine_SkeletonData_bones_get(self_) self_->getBones() + + +#define spine_SkeletonData_slots_get(self_) self_->getSlots() + + +#define spine_SkeletonData_skins_get(self_) self_->getSkins() + + +#define spine_SkeletonData_defaultSkin_get(self_) self_->getDefaultSkin() +#define spine_SkeletonData_defaultSkin_set(self_, val_) self_->setDefaultSkin(val_) + + +#define spine_SkeletonData_events_get(self_) self_->getEvents() + + +#define spine_SkeletonData_animations_get(self_) self_->getAnimations() + + +#define spine_SkeletonData_ikConstraints_get(self_) self_->getIkConstraints() + + +#define spine_SkeletonData_transformConstraints_get(self_) self_->getTransformConstraints() + + +#define spine_SkeletonData_pathConstraints_get(self_) self_->getPathConstraints() + + +#define spine_SkeletonData_x_get(self_) self_->getX() +#define spine_SkeletonData_x_set(self_, val_) self_->setX(val_) + + +#define spine_SkeletonData_y_get(self_) self_->getY() +#define spine_SkeletonData_y_set(self_, val_) self_->setY(val_) + + +#define spine_SkeletonData_width_get(self_) self_->getWidth() +#define spine_SkeletonData_width_set(self_, val_) self_->setWidth(val_) + + +#define spine_SkeletonData_height_get(self_) self_->getHeight() +#define spine_SkeletonData_height_set(self_, val_) self_->setHeight(val_) + + +#define spine_SkeletonData_version_get(self_) self_->getVersion() +#define spine_SkeletonData_version_set(self_, val_) self_->setVersion(val_) + + +#define spine_SkeletonData_hash_get(self_) self_->getHash() +#define spine_SkeletonData_hash_set(self_, val_) self_->setHash(val_) + + +#define spine_SkeletonData_fps_get(self_) self_->getFps() +#define spine_SkeletonData_fps_set(self_, val_) self_->setFps(val_) + + +#define spine_SkeletonData_imagesPath_get(self_) self_->getImagesPath() +#define spine_SkeletonData_imagesPath_set(self_, val_) self_->setImagesPath(val_) + + +#define spine_SkeletonData_audioPath_get(self_) self_->getAudioPath() +#define spine_SkeletonData_audioPath_set(self_, val_) self_->setAudioPath(val_) + + +#define spine_SkeletonJson_scale_get(self_) self_->setScale() + + +#define spine_Skin_name_get(self_) self_->getName() + + +#define spine_Skin_bones_get(self_) self_->getBones() + + +#define spine_Skin_constraints_get(self_) self_->getConstraints() + + +#define spine_Slot_data_get(self_) self_->getData() + + +#define spine_Slot_bone_get(self_) self_->getBone() + + +#define spine_Slot_color_get(self_) self_->getColor() + + +#define spine_Slot_darkColor_get(self_) self_->getDarkColor() + + +#define spine_Slot_attachment_get(self_) self_->getAttachment() +#define spine_Slot_attachment_set(self_, val_) self_->setAttachment(val_) + + +#define spine_Slot_deform_get(self_) self_->getDeform() + + +#define spine_SlotData_index_get(self_) self_->getIndex() + + +#define spine_SlotData_name_get(self_) self_->getName() + + +#define spine_SlotData_boneData_get(self_) self_->getBoneData() + + +#define spine_SlotData_color_get(self_) self_->getColor() + + +#define spine_SlotData_darkColor_get(self_) self_->getDarkColor() + + +#define spine_SlotData_attachmentName_get(self_) self_->getAttachmentName() +#define spine_SlotData_attachmentName_set(self_, val_) self_->setAttachmentName(val_) + + +#define spine_SlotData_blendMode_get(self_) self_->getBlendMode() +#define spine_SlotData_blendMode_set(self_, val_) self_->setBlendMode(val_) + + +#define spine_TransformConstraint_data_get(self_) self_->getData() + + +#define spine_TransformConstraint_bones_get(self_) self_->getBones() + + +#define spine_TransformConstraint_target_get(self_) self_->getTarget() +#define spine_TransformConstraint_target_set(self_, val_) self_->setTarget(val_) + + +#define spine_TransformConstraint_rotateMix_get(self_) self_->getRotateMix() +#define spine_TransformConstraint_rotateMix_set(self_, val_) self_->setRotateMix(val_) + + +#define spine_TransformConstraint_translateMix_get(self_) self_->getTranslateMix() +#define spine_TransformConstraint_translateMix_set(self_, val_) self_->setTranslateMix(val_) + + +#define spine_TransformConstraint_scaleMix_get(self_) self_->getScaleMix() +#define spine_TransformConstraint_scaleMix_set(self_, val_) self_->setScaleMix(val_) + + +#define spine_TransformConstraint_shearMix_get(self_) self_->getShearMix() +#define spine_TransformConstraint_shearMix_set(self_, val_) self_->setShearMix(val_) + + +#define spine_TransformConstraint_active_get(self_) self_->isActive() +#define spine_TransformConstraint_active_set(self_, val_) self_->setActive(val_) + + +#define spine_TransformConstraintData_bones_get(self_) self_->getBones() + + +#define spine_TransformConstraintData_target_get(self_) self_->getTarget() + + +#define spine_TransformConstraintData_rotateMix_get(self_) self_->getRotateMix() + + +#define spine_TransformConstraintData_translateMix_get(self_) self_->getTranslateMix() + + +#define spine_TransformConstraintData_scaleMix_get(self_) self_->getScaleMix() + + +#define spine_TransformConstraintData_shearMix_get(self_) self_->getShearMix() + + +#define spine_TransformConstraintData_offsetRotation_get(self_) self_->getOffsetRotation() + + +#define spine_TransformConstraintData_offsetX_get(self_) self_->getOffsetX() + + +#define spine_TransformConstraintData_offsetY_get(self_) self_->getOffsetY() + + +#define spine_TransformConstraintData_offsetScaleX_get(self_) self_->getOffsetScaleX() + + +#define spine_TransformConstraintData_offsetScaleY_get(self_) self_->getOffsetScaleY() + + +#define spine_TransformConstraintData_offsetShearY_get(self_) self_->getOffsetShearY() + + +#define spine_TransformConstraintData_relative_get(self_) self_->isRelative() + + +#define spine_TransformConstraintData_local_get(self_) self_->isLocal() + + +#define spine_Attachment_name_get(self_) self_->getName() + + +#define spine_VertexAttachment_id_get(self_) self_->getId() + + +#define spine_VertexAttachment_bones_get(self_) self_->getBones() + + +#define spine_VertexAttachment_vertices_get(self_) self_->getVertices() + + +#define spine_VertexAttachment_worldVerticesLength_get(self_) self_->getWorldVerticesLength() +#define spine_VertexAttachment_worldVerticesLength_set(self_, val_) self_->setWorldVerticesLength(val_) + + +#define spine_VertexAttachment_deformAttachment_get(self_) self_->getDeformAttachment() +#define spine_VertexAttachment_deformAttachment_set(self_, val_) self_->setDeformAttachment(val_) + + +#define spine_ClippingAttachment_endSlot_get(self_) self_->getEndSlot() +#define spine_ClippingAttachment_endSlot_set(self_, val_) self_->setEndSlot(val_) + + +#define spine_MeshAttachment_path_get(self_) self_->getPath() +#define spine_MeshAttachment_path_set(self_, val_) self_->setPath(val_) + + +#define spine_MeshAttachment_regionUVs_get(self_) self_->getRegionUVs() + + +#define spine_MeshAttachment_uvs_get(self_) self_->getUVs() + + +#define spine_MeshAttachment_triangles_get(self_) self_->getTriangles() + + +#define spine_MeshAttachment_color_get(self_) self_->getColor() + + +#define spine_MeshAttachment_width_get(self_) self_->getWidth() +#define spine_MeshAttachment_width_set(self_, val_) self_->setWidth(val_) + + +#define spine_MeshAttachment_height_get(self_) self_->getHeight() +#define spine_MeshAttachment_height_set(self_, val_) self_->setHeight(val_) + + +#define spine_MeshAttachment_hullLength_get(self_) self_->getHullLength() +#define spine_MeshAttachment_hullLength_set(self_, val_) self_->setHullLength(val_) + + +#define spine_MeshAttachment_edges_get(self_) self_->getEdges() + + +#define spine_PathAttachment_lengths_get(self_) self_->getLengths() + + +#define spine_PathAttachment_closed_get(self_) self_->isClosed() +#define spine_PathAttachment_closed_set(self_, val_) self_->setClosed(val_) + + +#define spine_PathAttachment_constantSpeed_get(self_) self_->isConstantSpeed() +#define spine_PathAttachment_constantSpeed_set(self_, val_) self_->setConstantSpeed(val_) + + +#define spine_PointAttachment_x_get(self_) self_->getX() +#define spine_PointAttachment_x_set(self_, val_) self_->setX(val_) + + +#define spine_PointAttachment_y_get(self_) self_->getY() +#define spine_PointAttachment_y_set(self_, val_) self_->setY(val_) + + +#define spine_PointAttachment_rotation_get(self_) self_->getRotation() +#define spine_PointAttachment_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_RegionAttachment_x_get(self_) self_->getX() +#define spine_RegionAttachment_x_set(self_, val_) self_->setX(val_) + + +#define spine_RegionAttachment_y_get(self_) self_->getY() +#define spine_RegionAttachment_y_set(self_, val_) self_->setY(val_) + + +#define spine_RegionAttachment_scaleX_get(self_) self_->getScaleX() +#define spine_RegionAttachment_scaleX_set(self_, val_) self_->setScaleX(val_) + + +#define spine_RegionAttachment_scaleY_get(self_) self_->getScaleY() +#define spine_RegionAttachment_scaleY_set(self_, val_) self_->setScaleY(val_) + + +#define spine_RegionAttachment_rotation_get(self_) self_->getRotation() +#define spine_RegionAttachment_rotation_set(self_, val_) self_->setRotation(val_) + + +#define spine_RegionAttachment_width_get(self_) self_->getWidth() +#define spine_RegionAttachment_width_set(self_, val_) self_->setWidth(val_) + + +#define spine_RegionAttachment_height_get(self_) self_->getHeight() +#define spine_RegionAttachment_height_set(self_, val_) self_->setHeight(val_) + + +#define spine_RegionAttachment_color_get(self_) self_->getColor() + + +#define spine_RegionAttachment_path_get(self_) self_->getPath() +#define spine_RegionAttachment_path_set(self_, val_) self_->setPath(val_) + + +#define spine_RegionAttachment_rendererObject_get(self_) self_->getRendererObject() +#define spine_RegionAttachment_rendererObject_set(self_, val_) self_->setRendererObject(val_) + + +#define spine_RegionAttachment_offset_get(self_) self_->getOffset() + + +#define spine_RegionAttachment_uvs_get(self_) self_->getUVs() + + +#define spine_JitterVertexEffect_jitterX_get(self_) self_->getJitterX() +#define spine_JitterVertexEffect_jitterX_set(self_, val_) self_->setJitterX(val_) + + +#define spine_JitterVertexEffect_jitterY_get(self_) self_->getJitterY() +#define spine_JitterVertexEffect_jitterY_set(self_, val_) self_->setJitterY(val_) + + +#define spine_SwirlVertexEffect_centerX_get(self_) self_->getCenterX() +#define spine_SwirlVertexEffect_centerX_set(self_, val_) self_->setCenterX(val_) + + +#define spine_SwirlVertexEffect_centerY_get(self_) self_->getCenterY() +#define spine_SwirlVertexEffect_centerY_set(self_, val_) self_->setCenterY(val_) + + +#define spine_SwirlVertexEffect_radius_get(self_) self_->getRadius() +#define spine_SwirlVertexEffect_radius_set(self_, val_) self_->setRadius(val_) + + +#define spine_SwirlVertexEffect_angle_get(self_) self_->getAngle() +#define spine_SwirlVertexEffect_angle_set(self_, val_) self_->setAngle(val_) + + +#define spine_Vector2_x_get(self_) self_->getX() +#define spine_Vector2_x_set(self_, val_) self_->setX(val_) + + +#define spine_Vector2_y_get(self_) self_->getY() +#define spine_Vector2_y_set(self_, val_) self_->setY(val_) + +SWIGINTERN void spine_Timeline_apply(spine::Timeline *self,spine::Skeleton *skeleton,float lastTime,float time,ccstd::vector< spine::Event * > const &events,float alpha,spine::MixBlend blend,spine::MixDirection direction){ + spine::Vector spEvents; + for (int i = 0; i < events.size(); ++i) { + spEvents.add(events[i]); + } + self->apply(*skeleton, lastTime, time, &spEvents, alpha, blend, direction); + } +SWIGINTERN void spine_Animation_apply(spine::Animation *self,spine::Skeleton *skeleton,float lastTime,float time,bool loop,ccstd::vector< spine::Event * > const &events,float alpha,spine::MixBlend blend,spine::MixDirection direction){ + spine::Vector spEvents; + for (int i = 0; i < events.size(); ++i) { + spEvents.add(events[i]); + } + self->apply(*skeleton, lastTime, time, loop, &spEvents, alpha, blend, direction); + } +SWIGINTERN void spine_AnimationState_apply(spine::AnimationState *self,spine::Skeleton *skeleton){ + self->apply(*skeleton); + } +SWIGINTERN spine::Bone *new_spine_Bone(spine::BoneData *data,spine::Skeleton *skeleton,spine::Bone *parent){ + return new Bone(*data, *skeleton, parent); + } +SWIGINTERN void spine_Bone_updateWorldTransformWith(spine::Bone *self,float x,float y,float rotation,float scaleX,float scaleY,float shearX,float shearY){ + self->updateWorldTransform(x, y, rotation, scaleX, scaleY, shearX, shearY); + } +SWIGINTERN spine::Color &spine_Color_setFromColor(spine::Color *self,spine::Color const &other){ + return self->set(other); + } +SWIGINTERN void spine_DeformTimeline_setFrame(spine::DeformTimeline *self,int frameIndex,float time,ccstd::vector< float > const &vertices){ + spine::Vector spVertices; + for (int i = 0; i < vertices.size(); ++i) { + spVertices.add(vertices[i]); + } + self->setFrame(frameIndex, time, spVertices); + } +SWIGINTERN void spine_DrawOrderTimeline_setFrame(spine::DrawOrderTimeline *self,size_t frameIndex,float time,ccstd::vector< int > const &drawOrder){ + spine::Vector spDrawOrder; + spDrawOrder.ensureCapacity(drawOrder.size()); + for (int i = 0; i < drawOrder.size(); ++i) { + spDrawOrder.add(drawOrder[i]); + } + self->setFrame(frameIndex, time, spDrawOrder); + } +SWIGINTERN spine::Event *new_spine_Event(float time,spine::EventData *data){ + return new Event(time, *data); + } +SWIGINTERN void spine_IkConstraint_apply1(spine::IkConstraint *self,spine::Bone *bone,float targetX,float targetY,bool compress,bool stretch,bool uniform,float alpha){ + IkConstraint::apply(*bone, targetX, targetY, compress, stretch, uniform, alpha); + } +SWIGINTERN void spine_IkConstraint_apply2(spine::IkConstraint *self,spine::Bone *parent,spine::Bone *child,float targetX,float targetY,int bendDir,bool stretch,float softness,float alpha){ + IkConstraint::apply(*parent, *child, targetX, targetY, bendDir, stretch, softness, alpha); + } +SWIGINTERN spine::IkConstraint *new_spine_IkConstraint(spine::IkConstraintData *data,spine::Skeleton *skeleton){ + return new IkConstraint(*data, *skeleton); + } +SWIGINTERN spine::PathConstraint *new_spine_PathConstraint(spine::PathConstraintData *data,spine::Skeleton *skeleton){ + return new PathConstraint(*data, *skeleton); + } +SWIGINTERN float spine_PointAttachment_computeWorldRotation(spine::PointAttachment *self,spine::Bone *bone){ + return self->computeWorldRotation(*bone); + } +SWIGINTERN spine::Attachment &spine_Skeleton_getAttachmentByName(spine::Skeleton *self,std::string const &slotName,std::string const &attachmentName){ + spine::String slot(slotName.data()); + spine::String attachment(attachmentName.data()); + return *(self->getAttachment(slot, attachment)); + } +SWIGINTERN spine::Slot *new_spine_Slot(spine::SlotData *data,spine::Bone *bone){ + return new Slot(*data, *bone); + } +SWIGINTERN void spine_SkeletonBounds_update(spine::SkeletonBounds *self,spine::Skeleton *skeleton,bool updateAabb){ + self->update(*skeleton, updateAabb); + } +SWIGINTERN spine::SlotData *new_spine_SlotData(int index,ccstd::string const *name,spine::BoneData *boneData){ + spine::String spName(name->data()); + return new SlotData(index, spName, *boneData); + } +SWIGINTERN spine::SkeletonData *spine_SkeletonBinary_readSkeletonData(spine::SkeletonBinary *self,std::vector< uint8_t > const &binary){ + std::vector input; + for (int i = 0; i < binary.size(); ++i) { + input.push_back(binary[i]); + } + return self->readSkeletonData(input.data(), input.size()); + } +SWIGINTERN spine::RegionAttachment *spine_AttachmentLoader_newRegionAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name,spine::String const &path){ + return self->newRegionAttachment(*skin, name, path); + } +SWIGINTERN spine::MeshAttachment *spine_AttachmentLoader_newMeshAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name,spine::String const &path){ + return self->newMeshAttachment(*skin, name, path); + } +SWIGINTERN spine::BoundingBoxAttachment *spine_AttachmentLoader_newBoundingBoxAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newBoundingBoxAttachment(*skin, name); + } +SWIGINTERN spine::PathAttachment *spine_AttachmentLoader_newPathAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newPathAttachment(*skin, name); + } +SWIGINTERN spine::PointAttachment *spine_AttachmentLoader_newPointAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newPointAttachment(*skin, name); + } +SWIGINTERN spine::ClippingAttachment *spine_AttachmentLoader_newClippingAttachment(spine::AttachmentLoader *self,spine::Skin *skin,spine::String const &name){ + return self->newClippingAttachment(*skin, name); + } +SWIGINTERN void spine_TextureLoader_load(spine::TextureLoader *self,spine::AtlasPage *page,spine::String const &path){ + self->load(*page, path); + } +SWIGINTERN spine::TransformConstraint *new_spine_TransformConstraint(spine::TransformConstraintData *data,spine::Skeleton *skeleton){ + return new TransformConstraint(*data, *skeleton); + } +SWIGINTERN void spine_VertexEffect_begin(spine::VertexEffect *self,spine::Skeleton *skeleton){ + self->begin(*skeleton); + } +SWIGINTERN spine::SwirlVertexEffect *new_spine_SwirlVertexEffect(float radius,spine::Interpolation *interpolation){ + return new SwirlVertexEffect(radius, *interpolation); + } + + +se::Class* __jsb_spine_MathUtil_class = nullptr; +se::Object* __jsb_spine_MathUtil_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_MathUtil) + +static bool js_spine_MathUtil_signum_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sign(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_signum_static) + +static bool js_spine_MathUtil_clamp_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::clamp(arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_clamp_static) + +static bool js_spine_MathUtil_abs_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::abs(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_abs_static) + +static bool js_spine_MathUtil_sin_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sin(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_sin_static) + +static bool js_spine_MathUtil_cos_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::cos(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_cos_static) + +static bool js_spine_MathUtil_sinDeg_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sinDeg(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_sinDeg_static) + +static bool js_spine_MathUtil_cosDeg_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::cosDeg(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_cosDeg_static) + +static bool js_spine_MathUtil_atan2_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::atan2(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_atan2_static) + +static bool js_spine_MathUtil_acos_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::acos(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_acos_static) + +static bool js_spine_MathUtil_sqrt_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::sqrt(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_sqrt_static) + +static bool js_spine_MathUtil_fmod_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::fmod(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_fmod_static) + +static bool js_spine_MathUtil_isNan_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)spine::MathUtil::isNan(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_isNan_static) + +static bool js_spine_MathUtil_random_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (float)spine::MathUtil::random(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_random_static) + +static bool js_spine_MathUtil_randomTriangular_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + float arg1 ; + float arg2 ; + float result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::randomTriangular(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_MathUtil_randomTriangular_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + float arg1 ; + float arg2 ; + float arg3 ; + float result; + + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::randomTriangular(arg1,arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_MathUtil_randomTriangular_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_spine_MathUtil_randomTriangular_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_spine_MathUtil_randomTriangular_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_MathUtil_randomTriangular_static) + +static bool js_spine_MathUtil_pow_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + float arg2 ; + float result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine::MathUtil::pow(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_pow_static) + +static bool js_spine_MathUtil_ipow_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + uint64_t arg1 ; + uint32_t arg2 ; + uint64_t result; + + 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], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = spine::MathUtil::ipow(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2)); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MathUtil_ipow_static) + +static bool js_delete_spine_MathUtil(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_MathUtil) + +bool js_register_spine_MathUtil(se::Object* obj) { + auto* cls = se::Class::create("MathUtil", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + cls->defineStaticFunction("signum", _SE(js_spine_MathUtil_signum_static)); + cls->defineStaticFunction("clamp", _SE(js_spine_MathUtil_clamp_static)); + cls->defineStaticFunction("abs", _SE(js_spine_MathUtil_abs_static)); + cls->defineStaticFunction("sin", _SE(js_spine_MathUtil_sin_static)); + cls->defineStaticFunction("cos", _SE(js_spine_MathUtil_cos_static)); + cls->defineStaticFunction("sinDeg", _SE(js_spine_MathUtil_sinDeg_static)); + cls->defineStaticFunction("cosDeg", _SE(js_spine_MathUtil_cosDeg_static)); + cls->defineStaticFunction("atan2", _SE(js_spine_MathUtil_atan2_static)); + cls->defineStaticFunction("acos", _SE(js_spine_MathUtil_acos_static)); + cls->defineStaticFunction("sqrt", _SE(js_spine_MathUtil_sqrt_static)); + cls->defineStaticFunction("fmod", _SE(js_spine_MathUtil_fmod_static)); + cls->defineStaticFunction("isNan", _SE(js_spine_MathUtil_isNan_static)); + cls->defineStaticFunction("random", _SE(js_spine_MathUtil_random_static)); + cls->defineStaticFunction("randomTriangular", _SE(js_spine_MathUtil_randomTriangular_static)); + cls->defineStaticFunction("pow", _SE(js_spine_MathUtil_pow_static)); + cls->defineStaticFunction("ipow", _SE(js_spine_MathUtil_ipow_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_spine_MathUtil)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_MathUtil_proto = cls->getProto(); + __jsb_spine_MathUtil_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Interpolation_class = nullptr; +se::Object* __jsb_spine_Interpolation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Interpolation) + +static bool js_spine_Interpolation_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Interpolation *arg1 = (spine::Interpolation *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->apply(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Interpolation_apply) + +static bool js_spine_Interpolation_interpolate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Interpolation *arg1 = (spine::Interpolation *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float result; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->interpolate(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Interpolation_interpolate) + +static bool js_delete_spine_Interpolation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Interpolation) + +template<> +bool sevalue_to_native(const se::Value &from, spine::Interpolation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + return ok; +} + + +bool js_register_spine_Interpolation(se::Object* obj) { + auto* cls = se::Class::create("Interpolation", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("apply", _SE(js_spine_Interpolation_apply)); + cls->defineFunction("interpolate", _SE(js_spine_Interpolation_interpolate)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Interpolation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Interpolation_proto = cls->getProto(); + __jsb_spine_Interpolation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PowInterpolation_class = nullptr; +se::Object* __jsb_spine_PowInterpolation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PowInterpolation) + +static bool js_new_spine_PowInterpolation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PowInterpolation *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PowInterpolation *)new spine::PowInterpolation(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PowInterpolation, __jsb_spine_PowInterpolation_class, js_delete_spine_PowInterpolation) + +static bool js_spine_PowInterpolation_power_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PowInterpolation *arg1 = (spine::PowInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->power, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PowInterpolation_power_set) + +static bool js_spine_PowInterpolation_power_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PowInterpolation *arg1 = (spine::PowInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->power, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PowInterpolation_power_get) + +static bool js_delete_spine_PowInterpolation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PowInterpolation) + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowInterpolation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("power", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->power), ctx); + } + + + return ok; +} + + +bool js_register_spine_PowInterpolation(se::Object* obj) { + auto* cls = se::Class::create("PowInterpolation", obj, __jsb_spine_Interpolation_proto, _SE(js_new_spine_PowInterpolation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("power", _SE(js_spine_PowInterpolation_power_get), _SE(js_spine_PowInterpolation_power_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PowInterpolation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PowInterpolation_proto = cls->getProto(); + __jsb_spine_PowInterpolation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PowOutInterpolation_class = nullptr; +se::Object* __jsb_spine_PowOutInterpolation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PowOutInterpolation) + +static bool js_new_spine_PowOutInterpolation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PowOutInterpolation *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PowOutInterpolation *)new spine::PowOutInterpolation(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PowOutInterpolation, __jsb_spine_PowOutInterpolation_class, js_delete_spine_PowOutInterpolation) + +static bool js_spine_PowOutInterpolation_power_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PowOutInterpolation *arg1 = (spine::PowOutInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->power, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PowOutInterpolation_power_set) + +static bool js_spine_PowOutInterpolation_power_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PowOutInterpolation *arg1 = (spine::PowOutInterpolation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->power, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PowOutInterpolation_power_get) + +static bool js_delete_spine_PowOutInterpolation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PowOutInterpolation) + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowOutInterpolation * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("power", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->power), ctx); + } + + + return ok; +} + + +bool js_register_spine_PowOutInterpolation(se::Object* obj) { + auto* cls = se::Class::create("PowOutInterpolation", obj, __jsb_spine_Interpolation_proto, _SE(js_new_spine_PowOutInterpolation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("power", _SE(js_spine_PowOutInterpolation_power_get), _SE(js_spine_PowOutInterpolation_power_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PowOutInterpolation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PowOutInterpolation_proto = cls->getProto(); + __jsb_spine_PowOutInterpolation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Timeline_class = nullptr; +se::Object* __jsb_spine_Timeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Timeline) + +static bool js_delete_spine_Timeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Timeline) + +static bool js_spine_Timeline_getPropertyId(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Timeline *arg1 = (spine::Timeline *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getPropertyId(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Timeline_getPropertyId) + +static bool js_spine_Timeline_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Timeline *arg1 = (spine::Timeline *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + float arg3 ; + float arg4 ; + ccstd::vector< spine::Event * > *arg5 = 0 ; + float arg6 ; + spine::MixBlend arg7 ; + spine::MixDirection arg8 ; + ccstd::vector< spine::Event * > temp5 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(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], &temp5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg5 = &temp5; + + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_Timeline_apply(arg1,arg2,arg3,arg4,(ccstd::vector< spine::Event * > const &)*arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_Timeline_apply) + +bool js_register_spine_Timeline(se::Object* obj) { + auto* cls = se::Class::create("Timeline", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getPropertyId", _SE(js_spine_Timeline_getPropertyId)); + cls->defineFunction("apply", _SE(js_spine_Timeline_apply)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Timeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Timeline_proto = cls->getProto(); + __jsb_spine_Timeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Animation_class = nullptr; +se::Object* __jsb_spine_Animation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Animation) + +static bool js_new_spine_Animation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + spine::String *arg1 = 0 ; + spine::Vector< spine::Timeline * > *arg2 = 0 ; + float arg3 ; + spine::String temp1 ; + spine::Vector< spine::Timeline * > temp2 ; + spine::Animation *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Animation *)new spine::Animation((spine::String const &)*arg1,*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Animation, __jsb_spine_Animation_class, js_delete_spine_Animation) + +static bool js_delete_spine_Animation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Animation) + +static bool js_spine_Animation_hasTimeline(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Animation *arg1 = (spine::Animation *) NULL ; + int arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->hasTimeline(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Animation_hasTimeline) + +static bool js_spine_Animation_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Animation *arg1 = (spine::Animation *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Animation_name_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_spine_Animation_name_get) + +static bool js_spine_Animation_timelines_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Animation *arg1 = (spine::Animation *) NULL ; + spine::Vector< spine::Timeline * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Timeline * > *) &spine_Animation_timelines_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_spine_Animation_timelines_get) + +static bool js_spine_Animation_duration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Animation *arg1 = (spine::Animation *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Animation_duration_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Animation_duration_set) + +static bool js_spine_Animation_duration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Animation *arg1 = (spine::Animation *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Animation_duration_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Animation_duration_get) + +static bool js_spine_Animation_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Animation *arg1 = (spine::Animation *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + float arg3 ; + float arg4 ; + bool arg5 ; + ccstd::vector< spine::Event * > *arg6 = 0 ; + float arg7 ; + spine::MixBlend arg8 ; + spine::MixDirection arg9 ; + ccstd::vector< spine::Event * > temp6 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &temp6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg6 = &temp6; + + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_Animation_apply(arg1,arg2,arg3,arg4,arg5,(ccstd::vector< spine::Event * > const &)*arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_spine_Animation_apply) + +bool js_register_spine_Animation(se::Object* obj) { + auto* cls = se::Class::create("Animation", obj, nullptr, _SE(js_new_spine_Animation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_Animation_name_get), nullptr); + cls->defineProperty("timelines", _SE(js_spine_Animation_timelines_get), nullptr); + cls->defineProperty("duration", _SE(js_spine_Animation_duration_get), _SE(js_spine_Animation_duration_set)); + + cls->defineFunction("hasTimeline", _SE(js_spine_Animation_hasTimeline)); + cls->defineFunction("apply", _SE(js_spine_Animation_apply)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Animation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Animation_proto = cls->getProto(); + __jsb_spine_Animation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AnimationStateListenerObject_class = nullptr; +se::Object* __jsb_spine_AnimationStateListenerObject_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AnimationStateListenerObject) + +static bool js_delete_spine_AnimationStateListenerObject(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AnimationStateListenerObject) + +static bool js_spine_AnimationStateListenerObject_callback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationStateListenerObject *arg1 = (spine::AnimationStateListenerObject *) NULL ; + spine::AnimationState *arg2 = (spine::AnimationState *) NULL ; + spine::EventType arg3 ; + spine::TrackEntry *arg4 = (spine::TrackEntry *) NULL ; + spine::Event *arg5 = (spine::Event *) NULL ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->callback(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationStateListenerObject_callback) + +bool js_register_spine_AnimationStateListenerObject(se::Object* obj) { + auto* cls = se::Class::create("AnimationStateListenerObject", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("callback", _SE(js_spine_AnimationStateListenerObject_callback)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AnimationStateListenerObject)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AnimationStateListenerObject_proto = cls->getProto(); + __jsb_spine_AnimationStateListenerObject_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TrackEntry_class = nullptr; +se::Object* __jsb_spine_TrackEntry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TrackEntry) + +static bool js_new_spine_TrackEntry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::TrackEntry *result; + result = (spine::TrackEntry *)new spine::TrackEntry(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TrackEntry, __jsb_spine_TrackEntry_class, js_delete_spine_TrackEntry) + +static bool js_delete_spine_TrackEntry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TrackEntry) + +static bool js_spine_TrackEntry_getAnimationTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getAnimationTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_TrackEntry_getAnimationTime) + +static bool js_spine_TrackEntry_isComplete(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->isComplete(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_TrackEntry_isComplete) + +static bool js_spine_TrackEntry_resetRotationDirections(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->resetRotationDirections(); + + + return true; +} +SE_BIND_FUNC(js_spine_TrackEntry_resetRotationDirections) + +static bool js_spine_TrackEntry_animation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::Animation *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Animation *)spine_TrackEntry_animation_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_spine_TrackEntry_animation_get) + +static bool js_spine_TrackEntry_next_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)spine_TrackEntry_next_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_spine_TrackEntry_next_get) + +static bool js_spine_TrackEntry_mixingFrom_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)spine_TrackEntry_mixingFrom_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_spine_TrackEntry_mixingFrom_get) + +static bool js_spine_TrackEntry_mixingTo_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)spine_TrackEntry_mixingTo_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_spine_TrackEntry_mixingTo_get) + +static bool js_spine_TrackEntry_trackIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_TrackEntry_trackIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_trackIndex_get) + +static bool js_spine_TrackEntry_loop_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_loop_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_loop_set) + +static bool js_spine_TrackEntry_loop_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TrackEntry_loop_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_loop_get) + +static bool js_spine_TrackEntry_holdPrevious_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_holdPrevious_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_holdPrevious_set) + +static bool js_spine_TrackEntry_holdPrevious_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TrackEntry_holdPrevious_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_holdPrevious_get) + +static bool js_spine_TrackEntry_eventThreshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_eventThreshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_eventThreshold_set) + +static bool js_spine_TrackEntry_eventThreshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_eventThreshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_eventThreshold_get) + +static bool js_spine_TrackEntry_attachmentThreshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_attachmentThreshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_attachmentThreshold_set) + +static bool js_spine_TrackEntry_attachmentThreshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_attachmentThreshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_attachmentThreshold_get) + +static bool js_spine_TrackEntry_drawOrderThreshold_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_drawOrderThreshold_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_drawOrderThreshold_set) + +static bool js_spine_TrackEntry_drawOrderThreshold_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_drawOrderThreshold_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_drawOrderThreshold_get) + +static bool js_spine_TrackEntry_animationStart_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_animationStart_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_animationStart_set) + +static bool js_spine_TrackEntry_animationStart_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_animationStart_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_animationStart_get) + +static bool js_spine_TrackEntry_animationEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_animationEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_animationEnd_set) + +static bool js_spine_TrackEntry_animationEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_animationEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_animationEnd_get) + +static bool js_spine_TrackEntry_animationLast_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_animationLast_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_animationLast_set) + +static bool js_spine_TrackEntry_animationLast_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_animationLast_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_animationLast_get) + +static bool js_spine_TrackEntry_delay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_delay_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_delay_set) + +static bool js_spine_TrackEntry_delay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_delay_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_delay_get) + +static bool js_spine_TrackEntry_trackTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_trackTime_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_trackTime_set) + +static bool js_spine_TrackEntry_trackTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_trackTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_trackTime_get) + +static bool js_spine_TrackEntry_trackEnd_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_trackEnd_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_trackEnd_set) + +static bool js_spine_TrackEntry_trackEnd_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_trackEnd_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_trackEnd_get) + +static bool js_spine_TrackEntry_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_timeScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_timeScale_set) + +static bool js_spine_TrackEntry_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_timeScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_timeScale_get) + +static bool js_spine_TrackEntry_alpha_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_alpha_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_alpha_set) + +static bool js_spine_TrackEntry_alpha_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_alpha_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_alpha_get) + +static bool js_spine_TrackEntry_mixTime_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_mixTime_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_mixTime_set) + +static bool js_spine_TrackEntry_mixTime_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_mixTime_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_mixTime_get) + +static bool js_spine_TrackEntry_mixDuration_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TrackEntry_mixDuration_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_mixDuration_set) + +static bool js_spine_TrackEntry_mixDuration_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TrackEntry_mixDuration_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TrackEntry_mixDuration_get) + +static bool js_spine_TrackEntry_mixBlend_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::MixBlend arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_TrackEntry_mixBlend_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TrackEntry_mixBlend_set) + +static bool js_spine_TrackEntry_mixBlend_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TrackEntry *arg1 = (spine::TrackEntry *) NULL ; + spine::MixBlend result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::MixBlend)spine_TrackEntry_mixBlend_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_spine_TrackEntry_mixBlend_get) + +bool js_register_spine_TrackEntry(se::Object* obj) { + auto* cls = se::Class::create("TrackEntry", obj, nullptr, _SE(js_new_spine_TrackEntry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("animation", _SE(js_spine_TrackEntry_animation_get), nullptr); + cls->defineProperty("next", _SE(js_spine_TrackEntry_next_get), nullptr); + cls->defineProperty("mixingFrom", _SE(js_spine_TrackEntry_mixingFrom_get), nullptr); + cls->defineProperty("mixingTo", _SE(js_spine_TrackEntry_mixingTo_get), nullptr); + cls->defineProperty("trackIndex", _SE(js_spine_TrackEntry_trackIndex_get), nullptr); + cls->defineProperty("loop", _SE(js_spine_TrackEntry_loop_get), _SE(js_spine_TrackEntry_loop_set)); + cls->defineProperty("holdPrevious", _SE(js_spine_TrackEntry_holdPrevious_get), _SE(js_spine_TrackEntry_holdPrevious_set)); + cls->defineProperty("eventThreshold", _SE(js_spine_TrackEntry_eventThreshold_get), _SE(js_spine_TrackEntry_eventThreshold_set)); + cls->defineProperty("attachmentThreshold", _SE(js_spine_TrackEntry_attachmentThreshold_get), _SE(js_spine_TrackEntry_attachmentThreshold_set)); + cls->defineProperty("drawOrderThreshold", _SE(js_spine_TrackEntry_drawOrderThreshold_get), _SE(js_spine_TrackEntry_drawOrderThreshold_set)); + cls->defineProperty("animationStart", _SE(js_spine_TrackEntry_animationStart_get), _SE(js_spine_TrackEntry_animationStart_set)); + cls->defineProperty("animationEnd", _SE(js_spine_TrackEntry_animationEnd_get), _SE(js_spine_TrackEntry_animationEnd_set)); + cls->defineProperty("animationLast", _SE(js_spine_TrackEntry_animationLast_get), _SE(js_spine_TrackEntry_animationLast_set)); + cls->defineProperty("delay", _SE(js_spine_TrackEntry_delay_get), _SE(js_spine_TrackEntry_delay_set)); + cls->defineProperty("trackTime", _SE(js_spine_TrackEntry_trackTime_get), _SE(js_spine_TrackEntry_trackTime_set)); + cls->defineProperty("trackEnd", _SE(js_spine_TrackEntry_trackEnd_get), _SE(js_spine_TrackEntry_trackEnd_set)); + cls->defineProperty("timeScale", _SE(js_spine_TrackEntry_timeScale_get), _SE(js_spine_TrackEntry_timeScale_set)); + cls->defineProperty("alpha", _SE(js_spine_TrackEntry_alpha_get), _SE(js_spine_TrackEntry_alpha_set)); + cls->defineProperty("mixTime", _SE(js_spine_TrackEntry_mixTime_get), _SE(js_spine_TrackEntry_mixTime_set)); + cls->defineProperty("mixDuration", _SE(js_spine_TrackEntry_mixDuration_get), _SE(js_spine_TrackEntry_mixDuration_set)); + cls->defineProperty("mixBlend", _SE(js_spine_TrackEntry_mixBlend_get), _SE(js_spine_TrackEntry_mixBlend_set)); + + cls->defineFunction("getAnimationTime", _SE(js_spine_TrackEntry_getAnimationTime)); + cls->defineFunction("isComplete", _SE(js_spine_TrackEntry_isComplete)); + cls->defineFunction("resetRotationDirections", _SE(js_spine_TrackEntry_resetRotationDirections)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TrackEntry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TrackEntry_proto = cls->getProto(); + __jsb_spine_TrackEntry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventQueueEntry_class = nullptr; +se::Object* __jsb_spine_EventQueueEntry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventQueueEntry) + +static bool js_spine_EventQueueEntry__type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventQueueEntry__type_set) + +static bool js_spine_EventQueueEntry__type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventQueueEntry__type_get) + +static bool js_spine_EventQueueEntry__entry_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_entry, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventQueueEntry__entry_set) + +static bool js_spine_EventQueueEntry__entry_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_entry, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_entry, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventQueueEntry__entry_get) + +static bool js_spine_EventQueueEntry__event_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_event, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventQueueEntry__event_set) + +static bool js_spine_EventQueueEntry__event_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventQueueEntry *arg1 = (spine::EventQueueEntry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_event, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_event, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventQueueEntry__event_get) + +static bool js_new_spine_EventQueueEntry__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::EventType arg1 ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + spine::Event *arg3 = (spine::Event *) NULL ; + spine::EventQueueEntry *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::EventQueueEntry *)new spine::EventQueueEntry(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_EventQueueEntry__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::EventType arg1 ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + spine::EventQueueEntry *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::EventQueueEntry *)new spine::EventQueueEntry(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_EventQueueEntry(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_spine_EventQueueEntry__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_spine_EventQueueEntry__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of EventQueueEntry"); + return false; +} +SE_BIND_CTOR(js_new_spine_EventQueueEntry, __jsb_spine_EventQueueEntry_class, js_delete_spine_EventQueueEntry) + +static bool js_delete_spine_EventQueueEntry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_EventQueueEntry) + +bool js_register_spine_EventQueueEntry(se::Object* obj) { + auto* cls = se::Class::create("EventQueueEntry", obj, nullptr, _SE(js_new_spine_EventQueueEntry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_type", _SE(js_spine_EventQueueEntry__type_get), _SE(js_spine_EventQueueEntry__type_set)); + cls->defineProperty("_entry", _SE(js_spine_EventQueueEntry__entry_get), _SE(js_spine_EventQueueEntry__entry_set)); + cls->defineProperty("_event", _SE(js_spine_EventQueueEntry__event_get), _SE(js_spine_EventQueueEntry__event_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_EventQueueEntry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventQueueEntry_proto = cls->getProto(); + __jsb_spine_EventQueueEntry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventQueue_class = nullptr; +se::Object* __jsb_spine_EventQueue_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventQueue) + +bool js_register_spine_EventQueue(se::Object* obj) { + auto* cls = se::Class::create("EventQueue", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventQueue_proto = cls->getProto(); + __jsb_spine_EventQueue_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AnimationState_class = nullptr; +se::Object* __jsb_spine_AnimationState_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AnimationState) + +static bool js_new_spine_AnimationState(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::AnimationState *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::AnimationState *)new spine::AnimationState(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AnimationState, __jsb_spine_AnimationState_class, js_delete_spine_AnimationState) + +static bool js_delete_spine_AnimationState(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AnimationState) + +static bool js_spine_AnimationState_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_update) + +static bool js_spine_AnimationState_clearTracks(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearTracks(); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_clearTracks) + +static bool js_spine_AnimationState_clearTrack(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->clearTrack(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_clearTrack) + +static bool js_spine_AnimationState_setAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + bool arg4 ; + spine::String temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->setAnimation(arg2,(spine::String const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_setAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + bool arg4 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->setAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_setAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_spine_AnimationState_setAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_spine_AnimationState_setAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_AnimationState_setAnimation) + +static bool js_spine_AnimationState_addAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + bool arg4 ; + float arg5 ; + spine::String temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,(spine::String const &)*arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_addAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + bool arg4 ; + float arg5 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_AnimationState_addAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_AnimationState_addAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 4) { + ok = js_spine_AnimationState_addAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_AnimationState_addAnimation) + +static bool js_spine_AnimationState_setEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + float arg3 ; + spine::TrackEntry *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(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 = (spine::TrackEntry *)(arg1)->setEmptyAnimation(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_spine_AnimationState_setEmptyAnimation) + +static bool js_spine_AnimationState_addEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + float arg3 ; + float arg4 ; + spine::TrackEntry *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addEmptyAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_addEmptyAnimation) + +static bool js_spine_AnimationState_setEmptyAnimations(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEmptyAnimations(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_setEmptyAnimations) + +static bool js_spine_AnimationState_getCurrent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + size_t arg2 ; + spine::TrackEntry *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (spine::TrackEntry *)(arg1)->getCurrent(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_spine_AnimationState_getCurrent) + +static bool js_spine_AnimationState_disableQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->disableQueue(); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_disableQueue) + +static bool js_spine_AnimationState_enableQueue(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->enableQueue(); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_enableQueue) + +static bool js_spine_AnimationState_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + spine::AnimationStateData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::AnimationStateData *)spine_AnimationState_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AnimationState_data_get) + +static bool js_spine_AnimationState_tracks_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + spine::Vector< spine::TrackEntry * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::TrackEntry * > *) &spine_AnimationState_tracks_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_spine_AnimationState_tracks_get) + +static bool js_spine_AnimationState_timeScale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_AnimationState_timeScale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_AnimationState_timeScale_set) + +static bool js_spine_AnimationState_timeScale_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_AnimationState_timeScale_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AnimationState_timeScale_get) + +static bool js_spine_AnimationState_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationState *arg1 = (spine::AnimationState *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_AnimationState_apply(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationState_apply) + +bool js_register_spine_AnimationState(se::Object* obj) { + auto* cls = se::Class::create("AnimationState", obj, nullptr, _SE(js_new_spine_AnimationState)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_AnimationState_data_get), nullptr); + cls->defineProperty("tracks", _SE(js_spine_AnimationState_tracks_get), nullptr); + cls->defineProperty("timeScale", _SE(js_spine_AnimationState_timeScale_get), _SE(js_spine_AnimationState_timeScale_set)); + + cls->defineFunction("update", _SE(js_spine_AnimationState_update)); + cls->defineFunction("clearTracks", _SE(js_spine_AnimationState_clearTracks)); + cls->defineFunction("clearTrack", _SE(js_spine_AnimationState_clearTrack)); + cls->defineFunction("setAnimation", _SE(js_spine_AnimationState_setAnimation)); + cls->defineFunction("addAnimation", _SE(js_spine_AnimationState_addAnimation)); + cls->defineFunction("setEmptyAnimation", _SE(js_spine_AnimationState_setEmptyAnimation)); + cls->defineFunction("addEmptyAnimation", _SE(js_spine_AnimationState_addEmptyAnimation)); + cls->defineFunction("setEmptyAnimations", _SE(js_spine_AnimationState_setEmptyAnimations)); + cls->defineFunction("getCurrent", _SE(js_spine_AnimationState_getCurrent)); + cls->defineFunction("disableQueue", _SE(js_spine_AnimationState_disableQueue)); + cls->defineFunction("enableQueue", _SE(js_spine_AnimationState_enableQueue)); + cls->defineFunction("apply", _SE(js_spine_AnimationState_apply)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AnimationState)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AnimationState_proto = cls->getProto(); + __jsb_spine_AnimationState_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AnimationStateData_class = nullptr; +se::Object* __jsb_spine_AnimationStateData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AnimationStateData) + +static bool js_new_spine_AnimationStateData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::AnimationStateData *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::AnimationStateData *)new spine::AnimationStateData(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AnimationStateData, __jsb_spine_AnimationStateData_class, js_delete_spine_AnimationStateData) + +static bool js_spine_AnimationStateData_setMixWith__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::String *arg2 = 0 ; + spine::String *arg3 = 0 ; + float arg4 ; + spine::String temp2 ; + spine::String temp3 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMix((spine::String const &)*arg2,(spine::String const &)*arg3,arg4); + + + return true; +} + +static bool js_spine_AnimationStateData_setMixWith__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::Animation *arg2 = (spine::Animation *) NULL ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + float arg4 ; + + arg1 = SE_THIS_OBJECT(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)->setMix(arg2,arg3,arg4); + + + return true; +} + +static bool js_spine_AnimationStateData_setMixWith(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_spine_AnimationStateData_setMixWith__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_spine_AnimationStateData_setMixWith__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_AnimationStateData_setMixWith) + +static bool js_spine_AnimationStateData_getMix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::Animation *arg2 = (spine::Animation *) NULL ; + spine::Animation *arg3 = (spine::Animation *) NULL ; + float result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (float)(arg1)->getMix(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_AnimationStateData_getMix) + +static bool js_spine_AnimationStateData_skeletonData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + spine::SkeletonData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SkeletonData *)spine_AnimationStateData_skeletonData_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_spine_AnimationStateData_skeletonData_get) + +static bool js_spine_AnimationStateData_defaultMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_AnimationStateData_defaultMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_AnimationStateData_defaultMix_set) + +static bool js_spine_AnimationStateData_defaultMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AnimationStateData *arg1 = (spine::AnimationStateData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_AnimationStateData_defaultMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AnimationStateData_defaultMix_get) + +static bool js_delete_spine_AnimationStateData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AnimationStateData) + +bool js_register_spine_AnimationStateData(se::Object* obj) { + auto* cls = se::Class::create("AnimationStateData", obj, nullptr, _SE(js_new_spine_AnimationStateData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("skeletonData", _SE(js_spine_AnimationStateData_skeletonData_get), nullptr); + cls->defineProperty("defaultMix", _SE(js_spine_AnimationStateData_defaultMix_get), _SE(js_spine_AnimationStateData_defaultMix_set)); + + cls->defineFunction("setMixWith", _SE(js_spine_AnimationStateData_setMixWith)); + cls->defineFunction("getMix", _SE(js_spine_AnimationStateData_getMix)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AnimationStateData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AnimationStateData_proto = cls->getProto(); + __jsb_spine_AnimationStateData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Attachment_class = nullptr; +se::Object* __jsb_spine_Attachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Attachment) + +static bool js_delete_spine_Attachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Attachment) + +static bool js_spine_Attachment_copy(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + result = (spine::Attachment *)(arg1)->copy(); + + 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_spine_Attachment_copy) + +static bool js_spine_Attachment_getRefCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)((spine::Attachment const *)arg1)->getRefCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Attachment_getRefCount) + +static bool js_spine_Attachment_reference(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->reference(); + + + return true; +} +SE_BIND_FUNC(js_spine_Attachment_reference) + +static bool js_spine_Attachment_dereference(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->dereference(); + + + return true; +} +SE_BIND_FUNC(js_spine_Attachment_dereference) + +static bool js_spine_Attachment_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Attachment *arg1 = (spine::Attachment *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Attachment_name_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_spine_Attachment_name_get) + +bool js_register_spine_Attachment(se::Object* obj) { + auto* cls = se::Class::create("Attachment", 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_spine_Attachment_name_get), nullptr); + + cls->defineFunction("copy", _SE(js_spine_Attachment_copy)); + cls->defineFunction("getRefCount", _SE(js_spine_Attachment_getRefCount)); + cls->defineFunction("reference", _SE(js_spine_Attachment_reference)); + cls->defineFunction("dereference", _SE(js_spine_Attachment_dereference)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Attachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Attachment_proto = cls->getProto(); + __jsb_spine_Attachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AttachmentTimeline_class = nullptr; +se::Object* __jsb_spine_AttachmentTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AttachmentTimeline) + +static bool js_new_spine_AttachmentTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::AttachmentTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::AttachmentTimeline *)new spine::AttachmentTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AttachmentTimeline, __jsb_spine_AttachmentTimeline_class, js_delete_spine_AttachmentTimeline) + +static bool js_spine_AttachmentTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + int arg2 ; + float arg3 ; + spine::String *arg4 = 0 ; + spine::String temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + (arg1)->setFrame(arg2,arg3,(spine::String const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentTimeline_setFrame) + +static bool js_spine_AttachmentTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentTimeline_getFrameCount) + +static bool js_spine_AttachmentTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + size_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_AttachmentTimeline_slotIndex_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_spine_AttachmentTimeline_slotIndex_set) + +static bool js_spine_AttachmentTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + size_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_AttachmentTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_AttachmentTimeline_slotIndex_get) + +static bool js_spine_AttachmentTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_AttachmentTimeline_frames_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_spine_AttachmentTimeline_frames_get) + +static bool js_spine_AttachmentTimeline_attachmentNames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AttachmentTimeline *arg1 = (spine::AttachmentTimeline *) NULL ; + spine::Vector< spine::String > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::String > *) &spine_AttachmentTimeline_attachmentNames_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_spine_AttachmentTimeline_attachmentNames_get) + +static bool js_delete_spine_AttachmentTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AttachmentTimeline) + +bool js_register_spine_AttachmentTimeline(se::Object* obj) { + auto* cls = se::Class::create("AttachmentTimeline", obj, __jsb_spine_Timeline_proto, _SE(js_new_spine_AttachmentTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_AttachmentTimeline_slotIndex_get), _SE(js_spine_AttachmentTimeline_slotIndex_set)); + cls->defineProperty("frames", _SE(js_spine_AttachmentTimeline_frames_get), nullptr); + cls->defineProperty("attachmentNames", _SE(js_spine_AttachmentTimeline_attachmentNames_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_AttachmentTimeline_setFrame)); + cls->defineFunction("getFrameCount", _SE(js_spine_AttachmentTimeline_getFrameCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AttachmentTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AttachmentTimeline_proto = cls->getProto(); + __jsb_spine_AttachmentTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_VertexAttachment_class = nullptr; +se::Object* __jsb_spine_VertexAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_VertexAttachment) + +static bool js_delete_spine_VertexAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_VertexAttachment) + +static bool js_spine_VertexAttachment_copyTo(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::VertexAttachment *arg2 = (spine::VertexAttachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->copyTo(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_VertexAttachment_copyTo) + +static bool js_spine_VertexAttachment_id_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_VertexAttachment_id_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_VertexAttachment_id_get) + +static bool js_spine_VertexAttachment_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::Vector< size_t > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< size_t > *) &spine_VertexAttachment_bones_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_spine_VertexAttachment_bones_get) + +static bool js_spine_VertexAttachment_vertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_VertexAttachment_vertices_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_spine_VertexAttachment_vertices_get) + +static bool js_spine_VertexAttachment_worldVerticesLength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + size_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_VertexAttachment_worldVerticesLength_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_spine_VertexAttachment_worldVerticesLength_set) + +static bool js_spine_VertexAttachment_worldVerticesLength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + size_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_VertexAttachment_worldVerticesLength_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_VertexAttachment_worldVerticesLength_get) + +static bool js_spine_VertexAttachment_deformAttachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::VertexAttachment *arg2 = (spine::VertexAttachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_VertexAttachment_deformAttachment_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_VertexAttachment_deformAttachment_set) + +static bool js_spine_VertexAttachment_deformAttachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::VertexAttachment *arg1 = (spine::VertexAttachment *) NULL ; + spine::VertexAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::VertexAttachment *)spine_VertexAttachment_deformAttachment_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_spine_VertexAttachment_deformAttachment_get) + +bool js_register_spine_VertexAttachment(se::Object* obj) { + auto* cls = se::Class::create("VertexAttachment", obj, __jsb_spine_Attachment_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("id", _SE(js_spine_VertexAttachment_id_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_VertexAttachment_bones_get), nullptr); + cls->defineProperty("vertices", _SE(js_spine_VertexAttachment_vertices_get), nullptr); + cls->defineProperty("worldVerticesLength", _SE(js_spine_VertexAttachment_worldVerticesLength_get), _SE(js_spine_VertexAttachment_worldVerticesLength_set)); + cls->defineProperty("deformAttachment", _SE(js_spine_VertexAttachment_deformAttachment_get), _SE(js_spine_VertexAttachment_deformAttachment_set)); + + cls->defineFunction("copyTo", _SE(js_spine_VertexAttachment_copyTo)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_VertexAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_VertexAttachment_proto = cls->getProto(); + __jsb_spine_VertexAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_BoundingBoxAttachment_class = nullptr; +se::Object* __jsb_spine_BoundingBoxAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_BoundingBoxAttachment) + +static bool js_new_spine_BoundingBoxAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::BoundingBoxAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::BoundingBoxAttachment *)new spine::BoundingBoxAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_BoundingBoxAttachment, __jsb_spine_BoundingBoxAttachment_class, js_delete_spine_BoundingBoxAttachment) + +static bool js_delete_spine_BoundingBoxAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_BoundingBoxAttachment) + +bool js_register_spine_BoundingBoxAttachment(se::Object* obj) { + auto* cls = se::Class::create("BoundingBoxAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_BoundingBoxAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_BoundingBoxAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_BoundingBoxAttachment_proto = cls->getProto(); + __jsb_spine_BoundingBoxAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Bone_class = nullptr; +se::Object* __jsb_spine_Bone_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Bone) + +static bool js_spine_Bone_setYDown_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool arg1 ; + + 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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine::Bone::setYDown(arg1); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_setYDown_static) + +static bool js_spine_Bone_isYDown_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + bool result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (bool)spine::Bone::isYDown(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_isYDown_static) + +static bool js_spine_Bone_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_update) + +static bool js_spine_Bone_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_updateWorldTransform) + +static bool js_spine_Bone_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_setToSetupPose) + +static bool js_spine_Bone_worldToLocalRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->worldToLocalRotation(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_worldToLocalRotation) + +static bool js_spine_Bone_localToWorldRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)(arg1)->localToWorldRotation(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_localToWorldRotation) + +static bool js_spine_Bone_rotateWorld(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->rotateWorld(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_rotateWorld) + +static bool js_spine_Bone_getWorldToLocalRotationX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldToLocalRotationX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldToLocalRotationX) + +static bool js_spine_Bone_getWorldToLocalRotationY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldToLocalRotationY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldToLocalRotationY) + +static bool js_spine_Bone_getWorldRotationX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldRotationX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldRotationX) + +static bool js_spine_Bone_getWorldRotationY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldRotationY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldRotationY) + +static bool js_spine_Bone_getWorldScaleX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldScaleX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldScaleX) + +static bool js_spine_Bone_getWorldScaleY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((spine::Bone const *)arg1)->getWorldScaleY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_getWorldScaleY) + +static bool js_spine_Bone_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *) &spine_Bone_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_data_get) + +static bool js_spine_Bone_skeleton_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::Skeleton *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *) &spine_Bone_skeleton_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_spine_Bone_skeleton_get) + +static bool js_spine_Bone_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)spine_Bone_parent_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_spine_Bone_parent_get) + +static bool js_spine_Bone_children_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_Bone_children_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_spine_Bone_children_get) + +static bool js_spine_Bone_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_x_set) + +static bool js_spine_Bone_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_x_get) + +static bool js_spine_Bone_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_y_set) + +static bool js_spine_Bone_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_y_get) + +static bool js_spine_Bone_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_rotation_set) + +static bool js_spine_Bone_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_rotation_get) + +static bool js_spine_Bone_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_scaleX_set) + +static bool js_spine_Bone_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_scaleX_get) + +static bool js_spine_Bone_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_scaleY_set) + +static bool js_spine_Bone_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_scaleY_get) + +static bool js_spine_Bone_shearX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_shearX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_shearX_set) + +static bool js_spine_Bone_shearX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_shearX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_shearX_get) + +static bool js_spine_Bone_shearY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_shearY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_shearY_set) + +static bool js_spine_Bone_shearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_shearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_shearY_get) + +static bool js_spine_Bone_ax_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ax_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ax_set) + +static bool js_spine_Bone_ax_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ax_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ax_get) + +static bool js_spine_Bone_ay_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ay_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ay_set) + +static bool js_spine_Bone_ay_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ay_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ay_get) + +static bool js_spine_Bone_arotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_arotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_arotation_set) + +static bool js_spine_Bone_arotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_arotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_arotation_get) + +static bool js_spine_Bone_ascaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ascaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ascaleX_set) + +static bool js_spine_Bone_ascaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ascaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ascaleX_get) + +static bool js_spine_Bone_ascaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ascaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ascaleY_set) + +static bool js_spine_Bone_ascaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ascaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ascaleY_get) + +static bool js_spine_Bone_ashearX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ashearX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ashearX_set) + +static bool js_spine_Bone_ashearX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ashearX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ashearX_get) + +static bool js_spine_Bone_ashearY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_ashearY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_ashearY_set) + +static bool js_spine_Bone_ashearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_ashearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_ashearY_get) + +static bool js_spine_Bone_appliedValid_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_appliedValid_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_appliedValid_set) + +static bool js_spine_Bone_appliedValid_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_Bone_appliedValid_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_appliedValid_get) + +static bool js_spine_Bone_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_a_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_a_set) + +static bool js_spine_Bone_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_a_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_a_get) + +static bool js_spine_Bone_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_b_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_b_set) + +static bool js_spine_Bone_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_b_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_b_get) + +static bool js_spine_Bone_c_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_c_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_c_set) + +static bool js_spine_Bone_c_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_c_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_c_get) + +static bool js_spine_Bone_d_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_d_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_d_set) + +static bool js_spine_Bone_d_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_d_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_d_get) + +static bool js_spine_Bone_worldX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_worldX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_worldX_set) + +static bool js_spine_Bone_worldX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_worldX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_worldX_get) + +static bool js_spine_Bone_worldY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_worldY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_worldY_set) + +static bool js_spine_Bone_worldY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Bone_worldY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_worldY_get) + +static bool js_spine_Bone_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Bone_active_set) + +static bool js_spine_Bone_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Bone *arg1 = (spine::Bone *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_Bone_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Bone_active_get) + +static bool js_new_spine_Bone(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::Bone *arg3 = (spine::Bone *) NULL ; + spine::Bone *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Bone *)new_spine_Bone(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Bone, __jsb_spine_Bone_class, js_delete_spine_Bone) + +static bool js_spine_Bone_updateWorldTransformWith(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Bone *arg1 = (spine::Bone *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Bone_updateWorldTransformWith(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_Bone_updateWorldTransformWith) + +static bool js_delete_spine_Bone(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Bone) + +bool js_register_spine_Bone(se::Object* obj) { + auto* cls = se::Class::create("Bone", obj, nullptr, _SE(js_new_spine_Bone)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Bone_data_get), nullptr); + cls->defineProperty("skeleton", _SE(js_spine_Bone_skeleton_get), nullptr); + cls->defineProperty("parent", _SE(js_spine_Bone_parent_get), nullptr); + cls->defineProperty("children", _SE(js_spine_Bone_children_get), nullptr); + cls->defineProperty("x", _SE(js_spine_Bone_x_get), _SE(js_spine_Bone_x_set)); + cls->defineProperty("y", _SE(js_spine_Bone_y_get), _SE(js_spine_Bone_y_set)); + cls->defineProperty("rotation", _SE(js_spine_Bone_rotation_get), _SE(js_spine_Bone_rotation_set)); + cls->defineProperty("scaleX", _SE(js_spine_Bone_scaleX_get), _SE(js_spine_Bone_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_Bone_scaleY_get), _SE(js_spine_Bone_scaleY_set)); + cls->defineProperty("shearX", _SE(js_spine_Bone_shearX_get), _SE(js_spine_Bone_shearX_set)); + cls->defineProperty("shearY", _SE(js_spine_Bone_shearY_get), _SE(js_spine_Bone_shearY_set)); + cls->defineProperty("ax", _SE(js_spine_Bone_ax_get), _SE(js_spine_Bone_ax_set)); + cls->defineProperty("ay", _SE(js_spine_Bone_ay_get), _SE(js_spine_Bone_ay_set)); + cls->defineProperty("arotation", _SE(js_spine_Bone_arotation_get), _SE(js_spine_Bone_arotation_set)); + cls->defineProperty("ascaleX", _SE(js_spine_Bone_ascaleX_get), _SE(js_spine_Bone_ascaleX_set)); + cls->defineProperty("ascaleY", _SE(js_spine_Bone_ascaleY_get), _SE(js_spine_Bone_ascaleY_set)); + cls->defineProperty("ashearX", _SE(js_spine_Bone_ashearX_get), _SE(js_spine_Bone_ashearX_set)); + cls->defineProperty("ashearY", _SE(js_spine_Bone_ashearY_get), _SE(js_spine_Bone_ashearY_set)); + cls->defineProperty("appliedValid", _SE(js_spine_Bone_appliedValid_get), _SE(js_spine_Bone_appliedValid_set)); + cls->defineProperty("a", _SE(js_spine_Bone_a_get), _SE(js_spine_Bone_a_set)); + cls->defineProperty("b", _SE(js_spine_Bone_b_get), _SE(js_spine_Bone_b_set)); + cls->defineProperty("c", _SE(js_spine_Bone_c_get), _SE(js_spine_Bone_c_set)); + cls->defineProperty("d", _SE(js_spine_Bone_d_get), _SE(js_spine_Bone_d_set)); + cls->defineProperty("worldX", _SE(js_spine_Bone_worldX_get), _SE(js_spine_Bone_worldX_set)); + cls->defineProperty("worldY", _SE(js_spine_Bone_worldY_get), _SE(js_spine_Bone_worldY_set)); + cls->defineProperty("active", _SE(js_spine_Bone_active_get), _SE(js_spine_Bone_active_set)); + + cls->defineFunction("update", _SE(js_spine_Bone_update)); + cls->defineFunction("updateWorldTransform", _SE(js_spine_Bone_updateWorldTransform)); + cls->defineFunction("setToSetupPose", _SE(js_spine_Bone_setToSetupPose)); + cls->defineFunction("worldToLocalRotation", _SE(js_spine_Bone_worldToLocalRotation)); + cls->defineFunction("localToWorldRotation", _SE(js_spine_Bone_localToWorldRotation)); + cls->defineFunction("rotateWorld", _SE(js_spine_Bone_rotateWorld)); + cls->defineFunction("getWorldToLocalRotationX", _SE(js_spine_Bone_getWorldToLocalRotationX)); + cls->defineFunction("getWorldToLocalRotationY", _SE(js_spine_Bone_getWorldToLocalRotationY)); + cls->defineFunction("getWorldRotationX", _SE(js_spine_Bone_getWorldRotationX)); + cls->defineFunction("getWorldRotationY", _SE(js_spine_Bone_getWorldRotationY)); + cls->defineFunction("getWorldScaleX", _SE(js_spine_Bone_getWorldScaleX)); + cls->defineFunction("getWorldScaleY", _SE(js_spine_Bone_getWorldScaleY)); + cls->defineFunction("updateWorldTransformWith", _SE(js_spine_Bone_updateWorldTransformWith)); + + + cls->defineStaticFunction("setYDown", _SE(js_spine_Bone_setYDown_static)); + cls->defineStaticFunction("isYDown", _SE(js_spine_Bone_isYDown_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Bone)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Bone_proto = cls->getProto(); + __jsb_spine_Bone_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_BoneData_class = nullptr; +se::Object* __jsb_spine_BoneData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_BoneData) + +static bool js_new_spine_BoneData__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + int arg1 ; + spine::String *arg2 = 0 ; + spine::BoneData *arg3 = (spine::BoneData *) NULL ; + spine::String temp2 ; + spine::BoneData *result; + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::BoneData *)new spine::BoneData(arg1,(spine::String const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_BoneData__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + int arg1 ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::BoneData *result; + + 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 = (spine::BoneData *)new spine::BoneData(arg1,(spine::String const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_BoneData(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_spine_BoneData__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_spine_BoneData__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of BoneData"); + return false; +} +SE_BIND_CTOR(js_new_spine_BoneData, __jsb_spine_BoneData_class, js_delete_spine_BoneData) + +static bool js_spine_BoneData_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_BoneData_index_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_index_get) + +static bool js_spine_BoneData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_BoneData_name_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_spine_BoneData_name_get) + +static bool js_spine_BoneData_parent_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *)spine_BoneData_parent_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_spine_BoneData_parent_get) + +static bool js_spine_BoneData_length_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_length_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_length_set) + +static bool js_spine_BoneData_length_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_length_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_length_get) + +static bool js_spine_BoneData_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_x_set) + +static bool js_spine_BoneData_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_x_get) + +static bool js_spine_BoneData_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_y_set) + +static bool js_spine_BoneData_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_y_get) + +static bool js_spine_BoneData_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_rotation_set) + +static bool js_spine_BoneData_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_rotation_get) + +static bool js_spine_BoneData_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_scaleX_set) + +static bool js_spine_BoneData_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_scaleX_get) + +static bool js_spine_BoneData_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_scaleY_set) + +static bool js_spine_BoneData_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_scaleY_get) + +static bool js_spine_BoneData_shearX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_shearX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_shearX_set) + +static bool js_spine_BoneData_shearX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_shearX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_shearX_get) + +static bool js_spine_BoneData_shearY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_shearY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_shearY_set) + +static bool js_spine_BoneData_shearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_BoneData_shearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_shearY_get) + +static bool js_spine_BoneData_transformMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::TransformMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_BoneData_transformMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_transformMode_set) + +static bool js_spine_BoneData_transformMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + spine::TransformMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TransformMode)spine_BoneData_transformMode_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_spine_BoneData_transformMode_get) + +static bool js_spine_BoneData_skinRequired_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_BoneData_skinRequired_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_BoneData_skinRequired_set) + +static bool js_spine_BoneData_skinRequired_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::BoneData *arg1 = (spine::BoneData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_BoneData_skinRequired_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_BoneData_skinRequired_get) + +static bool js_delete_spine_BoneData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_BoneData) + +bool js_register_spine_BoneData(se::Object* obj) { + auto* cls = se::Class::create("BoneData", obj, nullptr, _SE(js_new_spine_BoneData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("index", _SE(js_spine_BoneData_index_get), nullptr); + cls->defineProperty("name", _SE(js_spine_BoneData_name_get), nullptr); + cls->defineProperty("parent", _SE(js_spine_BoneData_parent_get), nullptr); + cls->defineProperty("length", _SE(js_spine_BoneData_length_get), _SE(js_spine_BoneData_length_set)); + cls->defineProperty("x", _SE(js_spine_BoneData_x_get), _SE(js_spine_BoneData_x_set)); + cls->defineProperty("y", _SE(js_spine_BoneData_y_get), _SE(js_spine_BoneData_y_set)); + cls->defineProperty("rotation", _SE(js_spine_BoneData_rotation_get), _SE(js_spine_BoneData_rotation_set)); + cls->defineProperty("scaleX", _SE(js_spine_BoneData_scaleX_get), _SE(js_spine_BoneData_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_BoneData_scaleY_get), _SE(js_spine_BoneData_scaleY_set)); + cls->defineProperty("shearX", _SE(js_spine_BoneData_shearX_get), _SE(js_spine_BoneData_shearX_set)); + cls->defineProperty("shearY", _SE(js_spine_BoneData_shearY_get), _SE(js_spine_BoneData_shearY_set)); + cls->defineProperty("transformMode", _SE(js_spine_BoneData_transformMode_get), _SE(js_spine_BoneData_transformMode_set)); + cls->defineProperty("skinRequired", _SE(js_spine_BoneData_skinRequired_get), _SE(js_spine_BoneData_skinRequired_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_BoneData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_BoneData_proto = cls->getProto(); + __jsb_spine_BoneData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ClippingAttachment_class = nullptr; +se::Object* __jsb_spine_ClippingAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ClippingAttachment) + +static bool js_new_spine_ClippingAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::ClippingAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::ClippingAttachment *)new spine::ClippingAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ClippingAttachment, __jsb_spine_ClippingAttachment_class, js_delete_spine_ClippingAttachment) + +static bool js_spine_ClippingAttachment_endSlot_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ClippingAttachment *arg1 = (spine::ClippingAttachment *) NULL ; + spine::SlotData *arg2 = (spine::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_ClippingAttachment_endSlot_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ClippingAttachment_endSlot_set) + +static bool js_spine_ClippingAttachment_endSlot_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ClippingAttachment *arg1 = (spine::ClippingAttachment *) NULL ; + spine::SlotData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SlotData *)spine_ClippingAttachment_endSlot_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_spine_ClippingAttachment_endSlot_get) + +static bool js_delete_spine_ClippingAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ClippingAttachment) + +bool js_register_spine_ClippingAttachment(se::Object* obj) { + auto* cls = se::Class::create("ClippingAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_ClippingAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("endSlot", _SE(js_spine_ClippingAttachment_endSlot_get), _SE(js_spine_ClippingAttachment_endSlot_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ClippingAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ClippingAttachment_proto = cls->getProto(); + __jsb_spine_ClippingAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Color_class = nullptr; +se::Object* __jsb_spine_Color_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Color) + +static bool js_new_spine_Color__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Color *result; + result = (spine::Color *)new spine::Color(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Color__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + spine::Color *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Color *)new spine::Color(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Color(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_spine_Color__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_spine_Color__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of Color"); + return false; +} +SE_BIND_CTOR(js_new_spine_Color, __jsb_spine_Color_class, js_delete_spine_Color) + +static bool js_spine_Color_set__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Color *) &(arg1)->set(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Color_set__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *arg2 = 0 ; + spine::Color temp2 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::Color *) &(arg1)->set((spine::Color 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; +} + +static bool js_spine_Color_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_Color_set__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_spine_Color_set__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_Color_set) + +static bool js_spine_Color_add__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Color *) &(arg1)->add(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Color_add__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *arg2 = 0 ; + spine::Color temp2 ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::Color *) &(arg1)->add((spine::Color 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; +} + +static bool js_spine_Color_add(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_Color_add__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_spine_Color_add__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_Color_add) + +static bool js_spine_Color_clamp(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *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(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &(arg1)->clamp(); + + 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_spine_Color_clamp) + +static bool js_spine_Color_r_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->r, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_r_set) + +static bool js_spine_Color_r_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->r, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_r_get) + +static bool js_spine_Color_g_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->g, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_g_set) + +static bool js_spine_Color_g_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->g, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_g_get) + +static bool js_spine_Color_b_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->b, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_b_set) + +static bool js_spine_Color_b_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->b, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_b_get) + +static bool js_spine_Color_a_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->a, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Color_a_set) + +static bool js_spine_Color_a_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Color *arg1 = (spine::Color *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->a, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Color_a_get) + +static bool js_spine_Color_setFromColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Color *arg1 = (spine::Color *) NULL ; + spine::Color *arg2 = 0 ; + spine::Color temp2 ; + spine::Color *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(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 = (spine::Color *) &spine_Color_setFromColor(arg1,(spine::Color 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_spine_Color_setFromColor) + +static bool js_delete_spine_Color(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Color) + +bool js_register_spine_Color(se::Object* obj) { + auto* cls = se::Class::create("Color", obj, nullptr, _SE(js_new_spine_Color)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("r", _SE(js_spine_Color_r_get), _SE(js_spine_Color_r_set)); + cls->defineProperty("g", _SE(js_spine_Color_g_get), _SE(js_spine_Color_g_set)); + cls->defineProperty("b", _SE(js_spine_Color_b_get), _SE(js_spine_Color_b_set)); + cls->defineProperty("a", _SE(js_spine_Color_a_get), _SE(js_spine_Color_a_set)); + + cls->defineFunction("set", _SE(js_spine_Color_set)); + cls->defineFunction("add", _SE(js_spine_Color_add)); + cls->defineFunction("clamp", _SE(js_spine_Color_clamp)); + cls->defineFunction("setFromColor", _SE(js_spine_Color_setFromColor)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Color)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Color_proto = cls->getProto(); + __jsb_spine_Color_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_CurveTimeline_class = nullptr; +se::Object* __jsb_spine_CurveTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_CurveTimeline) + +static bool js_delete_spine_CurveTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_CurveTimeline) + +static bool js_spine_CurveTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_getFrameCount) + +static bool js_spine_CurveTimeline_setLinear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setLinear(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_setLinear) + +static bool js_spine_CurveTimeline_setStepped(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setStepped(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_setStepped) + +static bool js_spine_CurveTimeline_setCurve(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setCurve(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_setCurve) + +static bool js_spine_CurveTimeline_getCurvePercent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + float result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (float)(arg1)->getCurvePercent(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_getCurvePercent) + +static bool js_spine_CurveTimeline_getCurveType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::CurveTimeline *arg1 = (spine::CurveTimeline *) NULL ; + size_t arg2 ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + result = (float)(arg1)->getCurveType(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_CurveTimeline_getCurveType) + +bool js_register_spine_CurveTimeline(se::Object* obj) { + auto* cls = se::Class::create("CurveTimeline", obj, __jsb_spine_Timeline_proto, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("getFrameCount", _SE(js_spine_CurveTimeline_getFrameCount)); + cls->defineFunction("setLinear", _SE(js_spine_CurveTimeline_setLinear)); + cls->defineFunction("setStepped", _SE(js_spine_CurveTimeline_setStepped)); + cls->defineFunction("setCurve", _SE(js_spine_CurveTimeline_setCurve)); + cls->defineFunction("getCurvePercent", _SE(js_spine_CurveTimeline_getCurvePercent)); + cls->defineFunction("getCurveType", _SE(js_spine_CurveTimeline_getCurveType)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_CurveTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_CurveTimeline_proto = cls->getProto(); + __jsb_spine_CurveTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ColorTimeline_class = nullptr; +se::Object* __jsb_spine_ColorTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ColorTimeline) + +static bool js_new_spine_ColorTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::ColorTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::ColorTimeline *)new spine::ColorTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ColorTimeline, __jsb_spine_ColorTimeline_class, js_delete_spine_ColorTimeline) + +static bool js_spine_ColorTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_spine_ColorTimeline_setFrame) + +static bool js_spine_ColorTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_ColorTimeline_slotIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ColorTimeline_slotIndex_set) + +static bool js_spine_ColorTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_ColorTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_ColorTimeline_slotIndex_get) + +static bool js_spine_ColorTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ColorTimeline *arg1 = (spine::ColorTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_ColorTimeline_frames_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_spine_ColorTimeline_frames_get) + +static bool js_delete_spine_ColorTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ColorTimeline) + +bool js_register_spine_ColorTimeline(se::Object* obj) { + auto* cls = se::Class::create("ColorTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_ColorTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_ColorTimeline_slotIndex_get), _SE(js_spine_ColorTimeline_slotIndex_set)); + cls->defineProperty("frames", _SE(js_spine_ColorTimeline_frames_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_ColorTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ColorTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ColorTimeline_proto = cls->getProto(); + __jsb_spine_ColorTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_DeformTimeline_class = nullptr; +se::Object* __jsb_spine_DeformTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_DeformTimeline) + +static bool js_new_spine_DeformTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::DeformTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::DeformTimeline *)new spine::DeformTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_DeformTimeline, __jsb_spine_DeformTimeline_class, js_delete_spine_DeformTimeline) + +static bool js_spine_DeformTimeline_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::VertexAttachment *arg2 = (spine::VertexAttachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachment(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_DeformTimeline_setAttachment) + +static bool js_spine_DeformTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_DeformTimeline_slotIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_DeformTimeline_slotIndex_set) + +static bool js_spine_DeformTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_DeformTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_DeformTimeline_slotIndex_get) + +static bool js_spine_DeformTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_DeformTimeline_frames_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_spine_DeformTimeline_frames_get) + +static bool js_spine_DeformTimeline_frameVertices_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_DeformTimeline_frameVertices_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_spine_DeformTimeline_frameVertices_get) + +static bool js_spine_DeformTimeline_attachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + spine::VertexAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::VertexAttachment *)spine_DeformTimeline_attachment_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_spine_DeformTimeline_attachment_get) + +static bool js_spine_DeformTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DeformTimeline *arg1 = (spine::DeformTimeline *) NULL ; + int arg2 ; + float arg3 ; + ccstd::vector< float > *arg4 = 0 ; + ccstd::vector< float > temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + spine_DeformTimeline_setFrame(arg1,arg2,arg3,(ccstd::vector< float > const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_DeformTimeline_setFrame) + +static bool js_delete_spine_DeformTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_DeformTimeline) + +bool js_register_spine_DeformTimeline(se::Object* obj) { + auto* cls = se::Class::create("DeformTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_DeformTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_DeformTimeline_slotIndex_get), _SE(js_spine_DeformTimeline_slotIndex_set)); + cls->defineProperty("frames", _SE(js_spine_DeformTimeline_frames_get), nullptr); + cls->defineProperty("frameVertices", _SE(js_spine_DeformTimeline_frameVertices_get), nullptr); + cls->defineProperty("attachment", _SE(js_spine_DeformTimeline_attachment_get), nullptr); + + cls->defineFunction("setAttachment", _SE(js_spine_DeformTimeline_setAttachment)); + cls->defineFunction("setFrame", _SE(js_spine_DeformTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_DeformTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_DeformTimeline_proto = cls->getProto(); + __jsb_spine_DeformTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_DrawOrderTimeline_class = nullptr; +se::Object* __jsb_spine_DrawOrderTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_DrawOrderTimeline) + +static bool js_new_spine_DrawOrderTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::DrawOrderTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::DrawOrderTimeline *)new spine::DrawOrderTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_DrawOrderTimeline, __jsb_spine_DrawOrderTimeline_class, js_delete_spine_DrawOrderTimeline) + +static bool js_spine_DrawOrderTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_DrawOrderTimeline_getFrameCount) + +static bool js_spine_DrawOrderTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_DrawOrderTimeline_frames_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_spine_DrawOrderTimeline_frames_get) + +static bool js_spine_DrawOrderTimeline_drawOrders_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + spine::Vector< spine::Vector< int > > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Vector< int > > *) &spine_DrawOrderTimeline_drawOrders_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_spine_DrawOrderTimeline_drawOrders_get) + +static bool js_spine_DrawOrderTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::DrawOrderTimeline *arg1 = (spine::DrawOrderTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + ccstd::vector< int > *arg4 = 0 ; + ccstd::vector< int > temp4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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; + + spine_DrawOrderTimeline_setFrame(arg1,SWIG_STD_MOVE(arg2),arg3,(ccstd::vector< int > const &)*arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_DrawOrderTimeline_setFrame) + +static bool js_delete_spine_DrawOrderTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_DrawOrderTimeline) + +bool js_register_spine_DrawOrderTimeline(se::Object* obj) { + auto* cls = se::Class::create("DrawOrderTimeline", obj, __jsb_spine_Timeline_proto, _SE(js_new_spine_DrawOrderTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frames", _SE(js_spine_DrawOrderTimeline_frames_get), nullptr); + cls->defineProperty("drawOrders", _SE(js_spine_DrawOrderTimeline_drawOrders_get), nullptr); + + cls->defineFunction("getFrameCount", _SE(js_spine_DrawOrderTimeline_getFrameCount)); + cls->defineFunction("setFrame", _SE(js_spine_DrawOrderTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_DrawOrderTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_DrawOrderTimeline_proto = cls->getProto(); + __jsb_spine_DrawOrderTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Event_class = nullptr; +se::Object* __jsb_spine_Event_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Event) + +static bool js_spine_Event_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + spine::EventData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::EventData *) &spine_Event_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_data_get) + +static bool js_spine_Event_intValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_intValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_intValue_set) + +static bool js_spine_Event_intValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_Event_intValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_intValue_get) + +static bool js_spine_Event_floatValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_floatValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_floatValue_set) + +static bool js_spine_Event_floatValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_floatValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_floatValue_get) + +static bool js_spine_Event_stringValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_Event_stringValue_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_stringValue_set) + +static bool js_spine_Event_stringValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Event_stringValue_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_spine_Event_stringValue_get) + +static bool js_spine_Event_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_time_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_time_get) + +static bool js_spine_Event_volume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_volume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_volume_set) + +static bool js_spine_Event_volume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_volume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_volume_get) + +static bool js_spine_Event_balance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Event *arg1 = (spine::Event *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Event_balance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Event_balance_set) + +static bool js_spine_Event_balance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Event *arg1 = (spine::Event *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Event_balance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Event_balance_get) + +static bool js_new_spine_Event(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + spine::EventData *arg2 = (spine::EventData *) NULL ; + spine::Event *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Event *)new_spine_Event(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Event, __jsb_spine_Event_class, js_delete_spine_Event) + +static bool js_delete_spine_Event(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Event) + +bool js_register_spine_Event(se::Object* obj) { + auto* cls = se::Class::create("Event", obj, nullptr, _SE(js_new_spine_Event)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Event_data_get), nullptr); + cls->defineProperty("intValue", _SE(js_spine_Event_intValue_get), _SE(js_spine_Event_intValue_set)); + cls->defineProperty("floatValue", _SE(js_spine_Event_floatValue_get), _SE(js_spine_Event_floatValue_set)); + cls->defineProperty("stringValue", _SE(js_spine_Event_stringValue_get), _SE(js_spine_Event_stringValue_set)); + cls->defineProperty("time", _SE(js_spine_Event_time_get), nullptr); + cls->defineProperty("volume", _SE(js_spine_Event_volume_get), _SE(js_spine_Event_volume_set)); + cls->defineProperty("balance", _SE(js_spine_Event_balance_get), _SE(js_spine_Event_balance_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Event)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Event_proto = cls->getProto(); + __jsb_spine_Event_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventData_class = nullptr; +se::Object* __jsb_spine_EventData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventData) + +static bool js_new_spine_EventData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::EventData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::EventData *)new spine::EventData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_EventData, __jsb_spine_EventData_class, js_delete_spine_EventData) + +static bool js_spine_EventData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_EventData_name_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_spine_EventData_name_get) + +static bool js_spine_EventData_intValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_intValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_intValue_set) + +static bool js_spine_EventData_intValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_EventData_intValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_intValue_get) + +static bool js_spine_EventData_floatValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_floatValue_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_floatValue_set) + +static bool js_spine_EventData_floatValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_EventData_floatValue_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_floatValue_get) + +static bool js_spine_EventData_stringValue_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_EventData_stringValue_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_stringValue_set) + +static bool js_spine_EventData_stringValue_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_EventData_stringValue_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_spine_EventData_stringValue_get) + +static bool js_spine_EventData_volume_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_volume_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_volume_set) + +static bool js_spine_EventData_volume_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_EventData_volume_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_volume_get) + +static bool js_spine_EventData_balance_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_EventData_balance_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_balance_set) + +static bool js_spine_EventData_balance_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_EventData_balance_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_EventData_balance_get) + +static bool js_spine_EventData_audioPath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_EventData_audioPath_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_EventData_audioPath_set) + +static bool js_spine_EventData_audioPath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventData *arg1 = (spine::EventData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_EventData_audioPath_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_spine_EventData_audioPath_get) + +static bool js_delete_spine_EventData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_EventData) + +bool js_register_spine_EventData(se::Object* obj) { + auto* cls = se::Class::create("EventData", obj, nullptr, _SE(js_new_spine_EventData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_EventData_name_get), nullptr); + cls->defineProperty("intValue", _SE(js_spine_EventData_intValue_get), _SE(js_spine_EventData_intValue_set)); + cls->defineProperty("floatValue", _SE(js_spine_EventData_floatValue_get), _SE(js_spine_EventData_floatValue_set)); + cls->defineProperty("stringValue", _SE(js_spine_EventData_stringValue_get), _SE(js_spine_EventData_stringValue_set)); + cls->defineProperty("volume", _SE(js_spine_EventData_volume_get), _SE(js_spine_EventData_volume_set)); + cls->defineProperty("balance", _SE(js_spine_EventData_balance_get), _SE(js_spine_EventData_balance_set)); + cls->defineProperty("audioPath", _SE(js_spine_EventData_audioPath_get), _SE(js_spine_EventData_audioPath_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_EventData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventData_proto = cls->getProto(); + __jsb_spine_EventData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_EventTimeline_class = nullptr; +se::Object* __jsb_spine_EventTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_EventTimeline) + +static bool js_new_spine_EventTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::EventTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::EventTimeline *)new spine::EventTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_EventTimeline, __jsb_spine_EventTimeline_class, js_delete_spine_EventTimeline) + +static bool js_delete_spine_EventTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_EventTimeline) + +static bool js_spine_EventTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + size_t arg2 ; + spine::Event *arg3 = (spine::Event *) NULL ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_EventTimeline_setFrame) + +static bool js_spine_EventTimeline_getFrameCount(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + size_t result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (arg1)->getFrameCount(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_EventTimeline_getFrameCount) + +static bool js_spine_EventTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + spine::Vector< float > result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_EventTimeline_frames_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_spine_EventTimeline_frames_get) + +static bool js_spine_EventTimeline_events_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::EventTimeline *arg1 = (spine::EventTimeline *) NULL ; + spine::Vector< spine::Event * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Event * > *) &spine_EventTimeline_events_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_spine_EventTimeline_events_get) + +bool js_register_spine_EventTimeline(se::Object* obj) { + auto* cls = se::Class::create("EventTimeline", obj, __jsb_spine_Timeline_proto, _SE(js_new_spine_EventTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("frames", _SE(js_spine_EventTimeline_frames_get), nullptr); + cls->defineProperty("events", _SE(js_spine_EventTimeline_events_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_EventTimeline_setFrame)); + cls->defineFunction("getFrameCount", _SE(js_spine_EventTimeline_getFrameCount)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_EventTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_EventTimeline_proto = cls->getProto(); + __jsb_spine_EventTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ConstraintData_class = nullptr; +se::Object* __jsb_spine_ConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ConstraintData) + +static bool js_new_spine_ConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::ConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::ConstraintData *)new spine::ConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ConstraintData, __jsb_spine_ConstraintData_class, js_delete_spine_ConstraintData) + +static bool js_delete_spine_ConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ConstraintData) + +static bool js_spine_ConstraintData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_ConstraintData_name_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_spine_ConstraintData_name_get) + +static bool js_spine_ConstraintData_order_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + size_t arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_ConstraintData_order_set(arg1,SWIG_STD_MOVE(arg2)); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ConstraintData_order_set) + +static bool js_spine_ConstraintData_order_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + size_t result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = spine_ConstraintData_order_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_ConstraintData_order_get) + +static bool js_spine_ConstraintData_skinRequired_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_ConstraintData_skinRequired_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_ConstraintData_skinRequired_set) + +static bool js_spine_ConstraintData_skinRequired_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::ConstraintData *arg1 = (spine::ConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_ConstraintData_skinRequired_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_ConstraintData_skinRequired_get) + +bool js_register_spine_ConstraintData(se::Object* obj) { + auto* cls = se::Class::create("ConstraintData", obj, nullptr, _SE(js_new_spine_ConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_ConstraintData_name_get), nullptr); + cls->defineProperty("order", _SE(js_spine_ConstraintData_order_get), _SE(js_spine_ConstraintData_order_set)); + cls->defineProperty("skinRequired", _SE(js_spine_ConstraintData_skinRequired_get), _SE(js_spine_ConstraintData_skinRequired_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ConstraintData_proto = cls->getProto(); + __jsb_spine_ConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_IkConstraint_class = nullptr; +se::Object* __jsb_spine_IkConstraint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_IkConstraint) + +static bool js_spine_IkConstraint_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->apply(); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_apply) + +static bool js_spine_IkConstraint_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_update) + +static bool js_spine_IkConstraint_getOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_getOrder) + +static bool js_spine_IkConstraint_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::IkConstraintData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::IkConstraintData *) &spine_IkConstraint_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_data_get) + +static bool js_spine_IkConstraint_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_IkConstraint_bones_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_spine_IkConstraint_bones_get) + +static bool js_spine_IkConstraint_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_target_set) + +static bool js_spine_IkConstraint_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)spine_IkConstraint_target_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_spine_IkConstraint_target_get) + +static bool js_spine_IkConstraint_bendDirection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_bendDirection_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_bendDirection_set) + +static bool js_spine_IkConstraint_bendDirection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_IkConstraint_bendDirection_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_bendDirection_get) + +static bool js_spine_IkConstraint_compress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_compress_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_compress_set) + +static bool js_spine_IkConstraint_compress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraint_compress_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_compress_get) + +static bool js_spine_IkConstraint_stretch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_stretch_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_stretch_set) + +static bool js_spine_IkConstraint_stretch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraint_stretch_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_stretch_get) + +static bool js_spine_IkConstraint_mix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_mix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_mix_set) + +static bool js_spine_IkConstraint_mix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraint_mix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_mix_get) + +static bool js_spine_IkConstraint_softness_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_softness_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_softness_set) + +static bool js_spine_IkConstraint_softness_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraint_softness_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_softness_get) + +static bool js_spine_IkConstraint_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraint_active_set) + +static bool js_spine_IkConstraint_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraint_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraint_active_get) + +static bool js_spine_IkConstraint_apply1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + float arg3 ; + float arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + float arg8 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_apply1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_apply1) + +static bool js_spine_IkConstraint_apply2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraint *arg1 = (spine::IkConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + spine::Bone *arg3 = (spine::Bone *) NULL ; + float arg4 ; + float arg5 ; + int arg6 ; + bool arg7 ; + float arg8 ; + float arg9 ; + + if(argc != 8) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 8); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraint_apply2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraint_apply2) + +static bool js_new_spine_IkConstraint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::IkConstraint *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::IkConstraint *)new_spine_IkConstraint(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_IkConstraint, __jsb_spine_IkConstraint_class, js_delete_spine_IkConstraint) + +static bool js_delete_spine_IkConstraint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_IkConstraint) + +bool js_register_spine_IkConstraint(se::Object* obj) { + auto* cls = se::Class::create("IkConstraint", obj, nullptr, _SE(js_new_spine_IkConstraint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_IkConstraint_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_IkConstraint_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_IkConstraint_target_get), _SE(js_spine_IkConstraint_target_set)); + cls->defineProperty("bendDirection", _SE(js_spine_IkConstraint_bendDirection_get), _SE(js_spine_IkConstraint_bendDirection_set)); + cls->defineProperty("compress", _SE(js_spine_IkConstraint_compress_get), _SE(js_spine_IkConstraint_compress_set)); + cls->defineProperty("stretch", _SE(js_spine_IkConstraint_stretch_get), _SE(js_spine_IkConstraint_stretch_set)); + cls->defineProperty("mix", _SE(js_spine_IkConstraint_mix_get), _SE(js_spine_IkConstraint_mix_set)); + cls->defineProperty("softness", _SE(js_spine_IkConstraint_softness_get), _SE(js_spine_IkConstraint_softness_set)); + cls->defineProperty("active", _SE(js_spine_IkConstraint_active_get), _SE(js_spine_IkConstraint_active_set)); + + cls->defineFunction("apply", _SE(js_spine_IkConstraint_apply)); + cls->defineFunction("update", _SE(js_spine_IkConstraint_update)); + cls->defineFunction("getOrder", _SE(js_spine_IkConstraint_getOrder)); + cls->defineFunction("apply1", _SE(js_spine_IkConstraint_apply1)); + cls->defineFunction("apply2", _SE(js_spine_IkConstraint_apply2)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_IkConstraint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_IkConstraint_proto = cls->getProto(); + __jsb_spine_IkConstraint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_IkConstraintData_class = nullptr; +se::Object* __jsb_spine_IkConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_IkConstraintData) + +static bool js_new_spine_IkConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::IkConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::IkConstraintData *)new spine::IkConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_IkConstraintData, __jsb_spine_IkConstraintData_class, js_delete_spine_IkConstraintData) + +static bool js_spine_IkConstraintData_setTarget(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::BoneData *arg2 = (spine::BoneData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTarget(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraintData_setTarget) + +static bool js_spine_IkConstraintData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_IkConstraintData_bones_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_spine_IkConstraintData_bones_get) + +static bool js_spine_IkConstraintData_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *)spine_IkConstraintData_target_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_spine_IkConstraintData_target_get) + +static bool js_spine_IkConstraintData_bendDirection_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_bendDirection_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_bendDirection_set) + +static bool js_spine_IkConstraintData_bendDirection_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_IkConstraintData_bendDirection_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_bendDirection_get) + +static bool js_spine_IkConstraintData_compress_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_compress_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_compress_set) + +static bool js_spine_IkConstraintData_compress_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraintData_compress_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_compress_get) + +static bool js_spine_IkConstraintData_stretch_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_stretch_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_stretch_set) + +static bool js_spine_IkConstraintData_stretch_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraintData_stretch_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_stretch_get) + +static bool js_spine_IkConstraintData_uniform_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_uniform_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_uniform_set) + +static bool js_spine_IkConstraintData_uniform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_IkConstraintData_uniform_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_uniform_get) + +static bool js_spine_IkConstraintData_mix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_mix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_mix_set) + +static bool js_spine_IkConstraintData_mix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraintData_mix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_mix_get) + +static bool js_spine_IkConstraintData_softness_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_IkConstraintData_softness_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_IkConstraintData_softness_set) + +static bool js_spine_IkConstraintData_softness_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::IkConstraintData *arg1 = (spine::IkConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_IkConstraintData_softness_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_IkConstraintData_softness_get) + +static bool js_delete_spine_IkConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_IkConstraintData) + +bool js_register_spine_IkConstraintData(se::Object* obj) { + auto* cls = se::Class::create("IkConstraintData", obj, __jsb_spine_ConstraintData_proto, _SE(js_new_spine_IkConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bones", _SE(js_spine_IkConstraintData_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_IkConstraintData_target_get), nullptr); + cls->defineProperty("bendDirection", _SE(js_spine_IkConstraintData_bendDirection_get), _SE(js_spine_IkConstraintData_bendDirection_set)); + cls->defineProperty("compress", _SE(js_spine_IkConstraintData_compress_get), _SE(js_spine_IkConstraintData_compress_set)); + cls->defineProperty("stretch", _SE(js_spine_IkConstraintData_stretch_get), _SE(js_spine_IkConstraintData_stretch_set)); + cls->defineProperty("uniform", _SE(js_spine_IkConstraintData_uniform_get), _SE(js_spine_IkConstraintData_uniform_set)); + cls->defineProperty("mix", _SE(js_spine_IkConstraintData_mix_get), _SE(js_spine_IkConstraintData_mix_set)); + cls->defineProperty("softness", _SE(js_spine_IkConstraintData_softness_get), _SE(js_spine_IkConstraintData_softness_set)); + + cls->defineFunction("setTarget", _SE(js_spine_IkConstraintData_setTarget)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_IkConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_IkConstraintData_proto = cls->getProto(); + __jsb_spine_IkConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_IkConstraintTimeline_class = nullptr; +se::Object* __jsb_spine_IkConstraintTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_IkConstraintTimeline) + +static bool js_new_spine_IkConstraintTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::IkConstraintTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::IkConstraintTimeline *)new spine::IkConstraintTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_IkConstraintTimeline, __jsb_spine_IkConstraintTimeline_class, js_delete_spine_IkConstraintTimeline) + +static bool js_spine_IkConstraintTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::IkConstraintTimeline *arg1 = (spine::IkConstraintTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + int arg6 ; + bool arg7 ; + bool arg8 ; + + if(argc != 7) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 7); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + + return true; +} +SE_BIND_FUNC(js_spine_IkConstraintTimeline_setFrame) + +static bool js_delete_spine_IkConstraintTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_IkConstraintTimeline) + +bool js_register_spine_IkConstraintTimeline(se::Object* obj) { + auto* cls = se::Class::create("IkConstraintTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_IkConstraintTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_IkConstraintTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_IkConstraintTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_IkConstraintTimeline_proto = cls->getProto(); + __jsb_spine_IkConstraintTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_MeshAttachment_class = nullptr; +se::Object* __jsb_spine_MeshAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_MeshAttachment) + +static bool js_new_spine_MeshAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::MeshAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::MeshAttachment *)new spine::MeshAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_MeshAttachment, __jsb_spine_MeshAttachment_class, js_delete_spine_MeshAttachment) + +static bool js_delete_spine_MeshAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_MeshAttachment) + +static bool js_spine_MeshAttachment_updateUVs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateUVs(); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_updateUVs) + +static bool js_spine_MeshAttachment_getRegionU(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionU(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionU) + +static bool js_spine_MeshAttachment_setRegionU(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionU(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionU) + +static bool js_spine_MeshAttachment_getRegionV(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionV(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionV) + +static bool js_spine_MeshAttachment_setRegionV(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionV(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionV) + +static bool js_spine_MeshAttachment_getRegionU2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionU2(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionU2) + +static bool js_spine_MeshAttachment_setRegionU2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionU2(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionU2) + +static bool js_spine_MeshAttachment_getRegionV2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionV2(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionV2) + +static bool js_spine_MeshAttachment_setRegionV2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionV2(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionV2) + +static bool js_spine_MeshAttachment_getRegionRotate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->getRegionRotate(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionRotate) + +static bool js_spine_MeshAttachment_setRegionRotate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionRotate(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionRotate) + +static bool js_spine_MeshAttachment_getRegionDegrees(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getRegionDegrees(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionDegrees) + +static bool js_spine_MeshAttachment_setRegionDegrees(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionDegrees(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionDegrees) + +static bool js_spine_MeshAttachment_getRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOffsetX) + +static bool js_spine_MeshAttachment_setRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetX(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOffsetX) + +static bool js_spine_MeshAttachment_getRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOffsetY) + +static bool js_spine_MeshAttachment_setRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetY(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOffsetY) + +static bool js_spine_MeshAttachment_getRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionWidth) + +static bool js_spine_MeshAttachment_setRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionWidth) + +static bool js_spine_MeshAttachment_getRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionHeight) + +static bool js_spine_MeshAttachment_setRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionHeight) + +static bool js_spine_MeshAttachment_getRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOriginalWidth) + +static bool js_spine_MeshAttachment_setRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOriginalWidth) + +static bool js_spine_MeshAttachment_getRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_getRegionOriginalHeight) + +static bool js_spine_MeshAttachment_setRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setRegionOriginalHeight) + +static bool js_spine_MeshAttachment_getParentMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::MeshAttachment *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(s); + if (nullptr == arg1) return true; + result = (spine::MeshAttachment *)(arg1)->getParentMesh(); + + 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_spine_MeshAttachment_getParentMesh) + +static bool js_spine_MeshAttachment_setParentMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::MeshAttachment *arg2 = (spine::MeshAttachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setParentMesh(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_MeshAttachment_setParentMesh) + +static bool js_spine_MeshAttachment_newLinkedMesh(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::MeshAttachment *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(s); + if (nullptr == arg1) return true; + result = (spine::MeshAttachment *)(arg1)->newLinkedMesh(); + + 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_spine_MeshAttachment_newLinkedMesh) + +static bool js_spine_MeshAttachment_path_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_MeshAttachment_path_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_path_set) + +static bool js_spine_MeshAttachment_path_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_MeshAttachment_path_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_spine_MeshAttachment_path_get) + +static bool js_spine_MeshAttachment_regionUVs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_MeshAttachment_regionUVs_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_spine_MeshAttachment_regionUVs_get) + +static bool js_spine_MeshAttachment_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_MeshAttachment_uvs_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_spine_MeshAttachment_uvs_get) + +static bool js_spine_MeshAttachment_triangles_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< unsigned short > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< unsigned short > *) &spine_MeshAttachment_triangles_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_spine_MeshAttachment_triangles_get) + +static bool js_spine_MeshAttachment_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_MeshAttachment_color_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_spine_MeshAttachment_color_get) + +static bool js_spine_MeshAttachment_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_MeshAttachment_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_width_set) + +static bool js_spine_MeshAttachment_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_MeshAttachment_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_MeshAttachment_width_get) + +static bool js_spine_MeshAttachment_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_MeshAttachment_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_height_set) + +static bool js_spine_MeshAttachment_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_MeshAttachment_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_MeshAttachment_height_get) + +static bool js_spine_MeshAttachment_hullLength_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_MeshAttachment_hullLength_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_MeshAttachment_hullLength_set) + +static bool js_spine_MeshAttachment_hullLength_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_MeshAttachment_hullLength_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_MeshAttachment_hullLength_get) + +static bool js_spine_MeshAttachment_edges_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::MeshAttachment *arg1 = (spine::MeshAttachment *) NULL ; + spine::Vector< unsigned short > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< unsigned short > *) &spine_MeshAttachment_edges_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_spine_MeshAttachment_edges_get) + +bool js_register_spine_MeshAttachment(se::Object* obj) { + auto* cls = se::Class::create("MeshAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_MeshAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("path", _SE(js_spine_MeshAttachment_path_get), _SE(js_spine_MeshAttachment_path_set)); + cls->defineProperty("regionUVs", _SE(js_spine_MeshAttachment_regionUVs_get), nullptr); + cls->defineProperty("uvs", _SE(js_spine_MeshAttachment_uvs_get), nullptr); + cls->defineProperty("triangles", _SE(js_spine_MeshAttachment_triangles_get), nullptr); + cls->defineProperty("color", _SE(js_spine_MeshAttachment_color_get), nullptr); + cls->defineProperty("width", _SE(js_spine_MeshAttachment_width_get), _SE(js_spine_MeshAttachment_width_set)); + cls->defineProperty("height", _SE(js_spine_MeshAttachment_height_get), _SE(js_spine_MeshAttachment_height_set)); + cls->defineProperty("hullLength", _SE(js_spine_MeshAttachment_hullLength_get), _SE(js_spine_MeshAttachment_hullLength_set)); + cls->defineProperty("edges", _SE(js_spine_MeshAttachment_edges_get), nullptr); + + cls->defineFunction("updateUVs", _SE(js_spine_MeshAttachment_updateUVs)); + cls->defineFunction("getRegionU", _SE(js_spine_MeshAttachment_getRegionU)); + cls->defineFunction("setRegionU", _SE(js_spine_MeshAttachment_setRegionU)); + cls->defineFunction("getRegionV", _SE(js_spine_MeshAttachment_getRegionV)); + cls->defineFunction("setRegionV", _SE(js_spine_MeshAttachment_setRegionV)); + cls->defineFunction("getRegionU2", _SE(js_spine_MeshAttachment_getRegionU2)); + cls->defineFunction("setRegionU2", _SE(js_spine_MeshAttachment_setRegionU2)); + cls->defineFunction("getRegionV2", _SE(js_spine_MeshAttachment_getRegionV2)); + cls->defineFunction("setRegionV2", _SE(js_spine_MeshAttachment_setRegionV2)); + cls->defineFunction("getRegionRotate", _SE(js_spine_MeshAttachment_getRegionRotate)); + cls->defineFunction("setRegionRotate", _SE(js_spine_MeshAttachment_setRegionRotate)); + cls->defineFunction("getRegionDegrees", _SE(js_spine_MeshAttachment_getRegionDegrees)); + cls->defineFunction("setRegionDegrees", _SE(js_spine_MeshAttachment_setRegionDegrees)); + cls->defineFunction("getRegionOffsetX", _SE(js_spine_MeshAttachment_getRegionOffsetX)); + cls->defineFunction("setRegionOffsetX", _SE(js_spine_MeshAttachment_setRegionOffsetX)); + cls->defineFunction("getRegionOffsetY", _SE(js_spine_MeshAttachment_getRegionOffsetY)); + cls->defineFunction("setRegionOffsetY", _SE(js_spine_MeshAttachment_setRegionOffsetY)); + cls->defineFunction("getRegionWidth", _SE(js_spine_MeshAttachment_getRegionWidth)); + cls->defineFunction("setRegionWidth", _SE(js_spine_MeshAttachment_setRegionWidth)); + cls->defineFunction("getRegionHeight", _SE(js_spine_MeshAttachment_getRegionHeight)); + cls->defineFunction("setRegionHeight", _SE(js_spine_MeshAttachment_setRegionHeight)); + cls->defineFunction("getRegionOriginalWidth", _SE(js_spine_MeshAttachment_getRegionOriginalWidth)); + cls->defineFunction("setRegionOriginalWidth", _SE(js_spine_MeshAttachment_setRegionOriginalWidth)); + cls->defineFunction("getRegionOriginalHeight", _SE(js_spine_MeshAttachment_getRegionOriginalHeight)); + cls->defineFunction("setRegionOriginalHeight", _SE(js_spine_MeshAttachment_setRegionOriginalHeight)); + cls->defineFunction("getParentMesh", _SE(js_spine_MeshAttachment_getParentMesh)); + cls->defineFunction("setParentMesh", _SE(js_spine_MeshAttachment_setParentMesh)); + cls->defineFunction("newLinkedMesh", _SE(js_spine_MeshAttachment_newLinkedMesh)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_MeshAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_MeshAttachment_proto = cls->getProto(); + __jsb_spine_MeshAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathAttachment_class = nullptr; +se::Object* __jsb_spine_PathAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathAttachment) + +static bool js_new_spine_PathAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::PathAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::PathAttachment *)new spine::PathAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathAttachment, __jsb_spine_PathAttachment_class, js_delete_spine_PathAttachment) + +static bool js_spine_PathAttachment_lengths_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_PathAttachment_lengths_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_spine_PathAttachment_lengths_get) + +static bool js_spine_PathAttachment_closed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathAttachment_closed_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathAttachment_closed_set) + +static bool js_spine_PathAttachment_closed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_PathAttachment_closed_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathAttachment_closed_get) + +static bool js_spine_PathAttachment_constantSpeed_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathAttachment_constantSpeed_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathAttachment_constantSpeed_set) + +static bool js_spine_PathAttachment_constantSpeed_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathAttachment *arg1 = (spine::PathAttachment *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_PathAttachment_constantSpeed_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathAttachment_constantSpeed_get) + +static bool js_delete_spine_PathAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathAttachment) + +bool js_register_spine_PathAttachment(se::Object* obj) { + auto* cls = se::Class::create("PathAttachment", obj, __jsb_spine_VertexAttachment_proto, _SE(js_new_spine_PathAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("lengths", _SE(js_spine_PathAttachment_lengths_get), nullptr); + cls->defineProperty("closed", _SE(js_spine_PathAttachment_closed_get), _SE(js_spine_PathAttachment_closed_set)); + cls->defineProperty("constantSpeed", _SE(js_spine_PathAttachment_constantSpeed_get), _SE(js_spine_PathAttachment_constantSpeed_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathAttachment_proto = cls->getProto(); + __jsb_spine_PathAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraint_class = nullptr; +se::Object* __jsb_spine_PathConstraint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraint) + +static bool js_spine_PathConstraint_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->apply(); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraint_apply) + +static bool js_spine_PathConstraint_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraint_update) + +static bool js_spine_PathConstraint_getOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraint_getOrder) + +static bool js_spine_PathConstraint_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::PathConstraintData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::PathConstraintData *) &spine_PathConstraint_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_data_get) + +static bool js_spine_PathConstraint_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_PathConstraint_bones_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_spine_PathConstraint_bones_get) + +static bool js_spine_PathConstraint_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::Slot *arg2 = (spine::Slot *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_target_set) + +static bool js_spine_PathConstraint_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + spine::Slot *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Slot *)spine_PathConstraint_target_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_spine_PathConstraint_target_get) + +static bool js_spine_PathConstraint_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_position_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_position_set) + +static bool js_spine_PathConstraint_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_position_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_position_get) + +static bool js_spine_PathConstraint_spacing_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_spacing_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_spacing_set) + +static bool js_spine_PathConstraint_spacing_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_spacing_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_spacing_get) + +static bool js_spine_PathConstraint_rotateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_rotateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_rotateMix_set) + +static bool js_spine_PathConstraint_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_rotateMix_get) + +static bool js_spine_PathConstraint_translateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_translateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_translateMix_set) + +static bool js_spine_PathConstraint_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraint_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_translateMix_get) + +static bool js_spine_PathConstraint_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraint_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraint_active_set) + +static bool js_spine_PathConstraint_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraint *arg1 = (spine::PathConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_PathConstraint_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraint_active_get) + +static bool js_new_spine_PathConstraint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::PathConstraint *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraint *)new_spine_PathConstraint(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraint, __jsb_spine_PathConstraint_class, js_delete_spine_PathConstraint) + +static bool js_delete_spine_PathConstraint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraint) + +bool js_register_spine_PathConstraint(se::Object* obj) { + auto* cls = se::Class::create("PathConstraint", obj, nullptr, _SE(js_new_spine_PathConstraint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_PathConstraint_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_PathConstraint_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_PathConstraint_target_get), _SE(js_spine_PathConstraint_target_set)); + cls->defineProperty("position", _SE(js_spine_PathConstraint_position_get), _SE(js_spine_PathConstraint_position_set)); + cls->defineProperty("spacing", _SE(js_spine_PathConstraint_spacing_get), _SE(js_spine_PathConstraint_spacing_set)); + cls->defineProperty("rotateMix", _SE(js_spine_PathConstraint_rotateMix_get), _SE(js_spine_PathConstraint_rotateMix_set)); + cls->defineProperty("translateMix", _SE(js_spine_PathConstraint_translateMix_get), _SE(js_spine_PathConstraint_translateMix_set)); + cls->defineProperty("active", _SE(js_spine_PathConstraint_active_get), _SE(js_spine_PathConstraint_active_set)); + + cls->defineFunction("apply", _SE(js_spine_PathConstraint_apply)); + cls->defineFunction("update", _SE(js_spine_PathConstraint_update)); + cls->defineFunction("getOrder", _SE(js_spine_PathConstraint_getOrder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraint_proto = cls->getProto(); + __jsb_spine_PathConstraint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintData_class = nullptr; +se::Object* __jsb_spine_PathConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintData) + +static bool js_new_spine_PathConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::PathConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::PathConstraintData *)new spine::PathConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintData, __jsb_spine_PathConstraintData_class, js_delete_spine_PathConstraintData) + +static bool js_spine_PathConstraintData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_PathConstraintData_bones_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_spine_PathConstraintData_bones_get) + +static bool js_spine_PathConstraintData_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SlotData *arg2 = (spine::SlotData *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_target_set) + +static bool js_spine_PathConstraintData_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SlotData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SlotData *)spine_PathConstraintData_target_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_spine_PathConstraintData_target_get) + +static bool js_spine_PathConstraintData_positionMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::PositionMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_PathConstraintData_positionMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_positionMode_set) + +static bool js_spine_PathConstraintData_positionMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::PositionMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::PositionMode)spine_PathConstraintData_positionMode_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_spine_PathConstraintData_positionMode_get) + +static bool js_spine_PathConstraintData_spacingMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SpacingMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_PathConstraintData_spacingMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_spacingMode_set) + +static bool js_spine_PathConstraintData_spacingMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::SpacingMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SpacingMode)spine_PathConstraintData_spacingMode_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_spine_PathConstraintData_spacingMode_get) + +static bool js_spine_PathConstraintData_rotateMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::RotateMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_PathConstraintData_rotateMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_rotateMode_set) + +static bool js_spine_PathConstraintData_rotateMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + spine::RotateMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::RotateMode)spine_PathConstraintData_rotateMode_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_spine_PathConstraintData_rotateMode_get) + +static bool js_spine_PathConstraintData_offsetRotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_offsetRotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_offsetRotation_set) + +static bool js_spine_PathConstraintData_offsetRotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_offsetRotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_offsetRotation_get) + +static bool js_spine_PathConstraintData_position_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_position_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_position_set) + +static bool js_spine_PathConstraintData_position_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_position_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_position_get) + +static bool js_spine_PathConstraintData_spacing_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_spacing_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_spacing_set) + +static bool js_spine_PathConstraintData_spacing_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_spacing_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_spacing_get) + +static bool js_spine_PathConstraintData_rotateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_rotateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_rotateMix_set) + +static bool js_spine_PathConstraintData_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_rotateMix_get) + +static bool js_spine_PathConstraintData_translateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PathConstraintData_translateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PathConstraintData_translateMix_set) + +static bool js_spine_PathConstraintData_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PathConstraintData *arg1 = (spine::PathConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PathConstraintData_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PathConstraintData_translateMix_get) + +static bool js_delete_spine_PathConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintData) + +bool js_register_spine_PathConstraintData(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintData", obj, __jsb_spine_ConstraintData_proto, _SE(js_new_spine_PathConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bones", _SE(js_spine_PathConstraintData_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_PathConstraintData_target_get), _SE(js_spine_PathConstraintData_target_set)); + cls->defineProperty("positionMode", _SE(js_spine_PathConstraintData_positionMode_get), _SE(js_spine_PathConstraintData_positionMode_set)); + cls->defineProperty("spacingMode", _SE(js_spine_PathConstraintData_spacingMode_get), _SE(js_spine_PathConstraintData_spacingMode_set)); + cls->defineProperty("rotateMode", _SE(js_spine_PathConstraintData_rotateMode_get), _SE(js_spine_PathConstraintData_rotateMode_set)); + cls->defineProperty("offsetRotation", _SE(js_spine_PathConstraintData_offsetRotation_get), _SE(js_spine_PathConstraintData_offsetRotation_set)); + cls->defineProperty("position", _SE(js_spine_PathConstraintData_position_get), _SE(js_spine_PathConstraintData_position_set)); + cls->defineProperty("spacing", _SE(js_spine_PathConstraintData_spacing_get), _SE(js_spine_PathConstraintData_spacing_set)); + cls->defineProperty("rotateMix", _SE(js_spine_PathConstraintData_rotateMix_get), _SE(js_spine_PathConstraintData_rotateMix_set)); + cls->defineProperty("translateMix", _SE(js_spine_PathConstraintData_translateMix_get), _SE(js_spine_PathConstraintData_translateMix_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintData_proto = cls->getProto(); + __jsb_spine_PathConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintMixTimeline_class = nullptr; +se::Object* __jsb_spine_PathConstraintMixTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintMixTimeline) + +static bool js_new_spine_PathConstraintMixTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PathConstraintMixTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraintMixTimeline *)new spine::PathConstraintMixTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintMixTimeline, __jsb_spine_PathConstraintMixTimeline_class, js_delete_spine_PathConstraintMixTimeline) + +static bool js_delete_spine_PathConstraintMixTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintMixTimeline) + +bool js_register_spine_PathConstraintMixTimeline(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintMixTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_PathConstraintMixTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintMixTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintMixTimeline_proto = cls->getProto(); + __jsb_spine_PathConstraintMixTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintPositionTimeline_class = nullptr; +se::Object* __jsb_spine_PathConstraintPositionTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintPositionTimeline) + +static bool js_new_spine_PathConstraintPositionTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PathConstraintPositionTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraintPositionTimeline *)new spine::PathConstraintPositionTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintPositionTimeline, __jsb_spine_PathConstraintPositionTimeline_class, js_delete_spine_PathConstraintPositionTimeline) + +static bool js_delete_spine_PathConstraintPositionTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintPositionTimeline) + +static bool js_spine_PathConstraintPositionTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PathConstraintPositionTimeline *arg1 = (spine::PathConstraintPositionTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_PathConstraintPositionTimeline_setFrame) + +bool js_register_spine_PathConstraintPositionTimeline(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintPositionTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_PathConstraintPositionTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_PathConstraintPositionTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintPositionTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintPositionTimeline_proto = cls->getProto(); + __jsb_spine_PathConstraintPositionTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PathConstraintSpacingTimeline_class = nullptr; +se::Object* __jsb_spine_PathConstraintSpacingTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PathConstraintSpacingTimeline) + +static bool js_new_spine_PathConstraintSpacingTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::PathConstraintSpacingTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::PathConstraintSpacingTimeline *)new spine::PathConstraintSpacingTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PathConstraintSpacingTimeline, __jsb_spine_PathConstraintSpacingTimeline_class, js_delete_spine_PathConstraintSpacingTimeline) + +static bool js_delete_spine_PathConstraintSpacingTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PathConstraintSpacingTimeline) + +bool js_register_spine_PathConstraintSpacingTimeline(se::Object* obj) { + auto* cls = se::Class::create("PathConstraintSpacingTimeline", obj, __jsb_spine_PathConstraintPositionTimeline_proto, _SE(js_new_spine_PathConstraintSpacingTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PathConstraintSpacingTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PathConstraintSpacingTimeline_proto = cls->getProto(); + __jsb_spine_PathConstraintSpacingTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_PointAttachment_class = nullptr; +se::Object* __jsb_spine_PointAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_PointAttachment) + +static bool js_new_spine_PointAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::PointAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::PointAttachment *)new spine::PointAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_PointAttachment, __jsb_spine_PointAttachment_class, js_delete_spine_PointAttachment) + +static bool js_spine_PointAttachment_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PointAttachment_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PointAttachment_x_set) + +static bool js_spine_PointAttachment_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PointAttachment_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PointAttachment_x_get) + +static bool js_spine_PointAttachment_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PointAttachment_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PointAttachment_y_set) + +static bool js_spine_PointAttachment_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PointAttachment_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PointAttachment_y_get) + +static bool js_spine_PointAttachment_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_PointAttachment_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_PointAttachment_rotation_set) + +static bool js_spine_PointAttachment_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_PointAttachment_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_PointAttachment_rotation_get) + +static bool js_spine_PointAttachment_computeWorldRotation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::PointAttachment *arg1 = (spine::PointAttachment *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + float result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (float)spine_PointAttachment_computeWorldRotation(arg1,arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_PointAttachment_computeWorldRotation) + +static bool js_delete_spine_PointAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_PointAttachment) + +bool js_register_spine_PointAttachment(se::Object* obj) { + auto* cls = se::Class::create("PointAttachment", obj, __jsb_spine_Attachment_proto, _SE(js_new_spine_PointAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_spine_PointAttachment_x_get), _SE(js_spine_PointAttachment_x_set)); + cls->defineProperty("y", _SE(js_spine_PointAttachment_y_get), _SE(js_spine_PointAttachment_y_set)); + cls->defineProperty("rotation", _SE(js_spine_PointAttachment_rotation_get), _SE(js_spine_PointAttachment_rotation_set)); + + cls->defineFunction("computeWorldRotation", _SE(js_spine_PointAttachment_computeWorldRotation)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_PointAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_PointAttachment_proto = cls->getProto(); + __jsb_spine_PointAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_RegionAttachment_class = nullptr; +se::Object* __jsb_spine_RegionAttachment_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_RegionAttachment) + +static bool js_new_spine_RegionAttachment(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::RegionAttachment *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::RegionAttachment *)new spine::RegionAttachment((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_RegionAttachment, __jsb_spine_RegionAttachment_class, js_delete_spine_RegionAttachment) + +static bool js_spine_RegionAttachment_updateOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateOffset(); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_updateOffset) + +static bool js_spine_RegionAttachment_setUVs(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + bool arg6 ; + + if(argc != 5) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUVs(arg2,arg3,arg4,arg5,arg6); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setUVs) + +static bool js_spine_RegionAttachment_getRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOffsetX) + +static bool js_spine_RegionAttachment_setRegionOffsetX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetX(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOffsetX) + +static bool js_spine_RegionAttachment_getRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOffsetY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOffsetY) + +static bool js_spine_RegionAttachment_setRegionOffsetY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOffsetY(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOffsetY) + +static bool js_spine_RegionAttachment_getRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionWidth) + +static bool js_spine_RegionAttachment_setRegionWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionWidth) + +static bool js_spine_RegionAttachment_getRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionHeight) + +static bool js_spine_RegionAttachment_setRegionHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionHeight) + +static bool js_spine_RegionAttachment_getRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOriginalWidth) + +static bool js_spine_RegionAttachment_setRegionOriginalWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalWidth(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOriginalWidth) + +static bool js_spine_RegionAttachment_getRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getRegionOriginalHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_getRegionOriginalHeight) + +static bool js_spine_RegionAttachment_setRegionOriginalHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRegionOriginalHeight(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_RegionAttachment_setRegionOriginalHeight) + +static bool js_spine_RegionAttachment_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_x_set) + +static bool js_spine_RegionAttachment_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_x_get) + +static bool js_spine_RegionAttachment_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_y_set) + +static bool js_spine_RegionAttachment_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_y_get) + +static bool js_spine_RegionAttachment_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_scaleX_set) + +static bool js_spine_RegionAttachment_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_scaleX_get) + +static bool js_spine_RegionAttachment_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_scaleY_set) + +static bool js_spine_RegionAttachment_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_scaleY_get) + +static bool js_spine_RegionAttachment_rotation_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_rotation_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_rotation_set) + +static bool js_spine_RegionAttachment_rotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_rotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_rotation_get) + +static bool js_spine_RegionAttachment_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_width_set) + +static bool js_spine_RegionAttachment_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_width_get) + +static bool js_spine_RegionAttachment_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_height_set) + +static bool js_spine_RegionAttachment_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_RegionAttachment_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RegionAttachment_height_get) + +static bool js_spine_RegionAttachment_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_RegionAttachment_color_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_spine_RegionAttachment_color_get) + +static bool js_spine_RegionAttachment_path_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_RegionAttachment_path_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_path_set) + +static bool js_spine_RegionAttachment_path_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_RegionAttachment_path_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_spine_RegionAttachment_path_get) + +static bool js_spine_RegionAttachment_rendererObject_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + void *arg2 = (void *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RegionAttachment_rendererObject_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RegionAttachment_rendererObject_set) + +static bool js_spine_RegionAttachment_rendererObject_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + void *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (void *)spine_RegionAttachment_rendererObject_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_spine_RegionAttachment_rendererObject_get) + +static bool js_spine_RegionAttachment_offset_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_RegionAttachment_offset_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_spine_RegionAttachment_offset_get) + +static bool js_spine_RegionAttachment_uvs_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RegionAttachment *arg1 = (spine::RegionAttachment *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_RegionAttachment_uvs_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_spine_RegionAttachment_uvs_get) + +static bool js_delete_spine_RegionAttachment(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_RegionAttachment) + +bool js_register_spine_RegionAttachment(se::Object* obj) { + auto* cls = se::Class::create("RegionAttachment", obj, __jsb_spine_Attachment_proto, _SE(js_new_spine_RegionAttachment)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("x", _SE(js_spine_RegionAttachment_x_get), _SE(js_spine_RegionAttachment_x_set)); + cls->defineProperty("y", _SE(js_spine_RegionAttachment_y_get), _SE(js_spine_RegionAttachment_y_set)); + cls->defineProperty("scaleX", _SE(js_spine_RegionAttachment_scaleX_get), _SE(js_spine_RegionAttachment_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_RegionAttachment_scaleY_get), _SE(js_spine_RegionAttachment_scaleY_set)); + cls->defineProperty("rotation", _SE(js_spine_RegionAttachment_rotation_get), _SE(js_spine_RegionAttachment_rotation_set)); + cls->defineProperty("width", _SE(js_spine_RegionAttachment_width_get), _SE(js_spine_RegionAttachment_width_set)); + cls->defineProperty("height", _SE(js_spine_RegionAttachment_height_get), _SE(js_spine_RegionAttachment_height_set)); + cls->defineProperty("color", _SE(js_spine_RegionAttachment_color_get), nullptr); + cls->defineProperty("path", _SE(js_spine_RegionAttachment_path_get), _SE(js_spine_RegionAttachment_path_set)); + cls->defineProperty("rendererObject", _SE(js_spine_RegionAttachment_rendererObject_get), _SE(js_spine_RegionAttachment_rendererObject_set)); + cls->defineProperty("offset", _SE(js_spine_RegionAttachment_offset_get), nullptr); + cls->defineProperty("uvs", _SE(js_spine_RegionAttachment_uvs_get), nullptr); + + cls->defineFunction("updateOffset", _SE(js_spine_RegionAttachment_updateOffset)); + cls->defineFunction("setUVs", _SE(js_spine_RegionAttachment_setUVs)); + cls->defineFunction("getRegionOffsetX", _SE(js_spine_RegionAttachment_getRegionOffsetX)); + cls->defineFunction("setRegionOffsetX", _SE(js_spine_RegionAttachment_setRegionOffsetX)); + cls->defineFunction("getRegionOffsetY", _SE(js_spine_RegionAttachment_getRegionOffsetY)); + cls->defineFunction("setRegionOffsetY", _SE(js_spine_RegionAttachment_setRegionOffsetY)); + cls->defineFunction("getRegionWidth", _SE(js_spine_RegionAttachment_getRegionWidth)); + cls->defineFunction("setRegionWidth", _SE(js_spine_RegionAttachment_setRegionWidth)); + cls->defineFunction("getRegionHeight", _SE(js_spine_RegionAttachment_getRegionHeight)); + cls->defineFunction("setRegionHeight", _SE(js_spine_RegionAttachment_setRegionHeight)); + cls->defineFunction("getRegionOriginalWidth", _SE(js_spine_RegionAttachment_getRegionOriginalWidth)); + cls->defineFunction("setRegionOriginalWidth", _SE(js_spine_RegionAttachment_setRegionOriginalWidth)); + cls->defineFunction("getRegionOriginalHeight", _SE(js_spine_RegionAttachment_getRegionOriginalHeight)); + cls->defineFunction("setRegionOriginalHeight", _SE(js_spine_RegionAttachment_setRegionOriginalHeight)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_RegionAttachment)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_RegionAttachment_proto = cls->getProto(); + __jsb_spine_RegionAttachment_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TranslateTimeline_class = nullptr; +se::Object* __jsb_spine_TranslateTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TranslateTimeline) + +static bool js_new_spine_TranslateTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::TranslateTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TranslateTimeline *)new spine::TranslateTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TranslateTimeline, __jsb_spine_TranslateTimeline_class, js_delete_spine_TranslateTimeline) + +static bool js_delete_spine_TranslateTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TranslateTimeline) + +static bool js_spine_TranslateTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TranslateTimeline *arg1 = (spine::TranslateTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_spine_TranslateTimeline_setFrame) + +bool js_register_spine_TranslateTimeline(se::Object* obj) { + auto* cls = se::Class::create("TranslateTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_TranslateTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_TranslateTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TranslateTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TranslateTimeline_proto = cls->getProto(); + __jsb_spine_TranslateTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TwoColorTimeline_class = nullptr; +se::Object* __jsb_spine_TwoColorTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TwoColorTimeline) + +static bool js_new_spine_TwoColorTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::TwoColorTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TwoColorTimeline *)new spine::TwoColorTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TwoColorTimeline, __jsb_spine_TwoColorTimeline_class, js_delete_spine_TwoColorTimeline) + +static bool js_spine_TwoColorTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TwoColorTimeline *arg1 = (spine::TwoColorTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + float arg10 ; + + if(argc != 9) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 9); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[6], &arg8, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[7], &arg9, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[8], &arg10, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + + + return true; +} +SE_BIND_FUNC(js_spine_TwoColorTimeline_setFrame) + +static bool js_spine_TwoColorTimeline_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TwoColorTimeline *arg1 = (spine::TwoColorTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TwoColorTimeline_slotIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TwoColorTimeline_slotIndex_set) + +static bool js_spine_TwoColorTimeline_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TwoColorTimeline *arg1 = (spine::TwoColorTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_TwoColorTimeline_slotIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TwoColorTimeline_slotIndex_get) + +static bool js_delete_spine_TwoColorTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TwoColorTimeline) + +bool js_register_spine_TwoColorTimeline(se::Object* obj) { + auto* cls = se::Class::create("TwoColorTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_TwoColorTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_TwoColorTimeline_slotIndex_get), _SE(js_spine_TwoColorTimeline_slotIndex_set)); + + cls->defineFunction("setFrame", _SE(js_spine_TwoColorTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TwoColorTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TwoColorTimeline_proto = cls->getProto(); + __jsb_spine_TwoColorTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_RotateTimeline_class = nullptr; +se::Object* __jsb_spine_RotateTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_RotateTimeline) + +static bool js_new_spine_RotateTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::RotateTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::RotateTimeline *)new spine::RotateTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_RotateTimeline, __jsb_spine_RotateTimeline_class, js_delete_spine_RotateTimeline) + +static bool js_spine_RotateTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setFrame(arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_RotateTimeline_setFrame) + +static bool js_spine_RotateTimeline_boneIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_RotateTimeline_boneIndex_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_RotateTimeline_boneIndex_set) + +static bool js_spine_RotateTimeline_boneIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_RotateTimeline_boneIndex_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_RotateTimeline_boneIndex_get) + +static bool js_spine_RotateTimeline_frames_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::RotateTimeline *arg1 = (spine::RotateTimeline *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_RotateTimeline_frames_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_spine_RotateTimeline_frames_get) + +static bool js_delete_spine_RotateTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_RotateTimeline) + +bool js_register_spine_RotateTimeline(se::Object* obj) { + auto* cls = se::Class::create("RotateTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_RotateTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("boneIndex", _SE(js_spine_RotateTimeline_boneIndex_get), _SE(js_spine_RotateTimeline_boneIndex_set)); + cls->defineProperty("frames", _SE(js_spine_RotateTimeline_frames_get), nullptr); + + cls->defineFunction("setFrame", _SE(js_spine_RotateTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_RotateTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_RotateTimeline_proto = cls->getProto(); + __jsb_spine_RotateTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ScaleTimeline_class = nullptr; +se::Object* __jsb_spine_ScaleTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ScaleTimeline) + +static bool js_new_spine_ScaleTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::ScaleTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::ScaleTimeline *)new spine::ScaleTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ScaleTimeline, __jsb_spine_ScaleTimeline_class, js_delete_spine_ScaleTimeline) + +static bool js_delete_spine_ScaleTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ScaleTimeline) + +bool js_register_spine_ScaleTimeline(se::Object* obj) { + auto* cls = se::Class::create("ScaleTimeline", obj, __jsb_spine_TranslateTimeline_proto, _SE(js_new_spine_ScaleTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ScaleTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ScaleTimeline_proto = cls->getProto(); + __jsb_spine_ScaleTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_ShearTimeline_class = nullptr; +se::Object* __jsb_spine_ShearTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_ShearTimeline) + +static bool js_new_spine_ShearTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::ShearTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::ShearTimeline *)new spine::ShearTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_ShearTimeline, __jsb_spine_ShearTimeline_class, js_delete_spine_ShearTimeline) + +static bool js_delete_spine_ShearTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_ShearTimeline) + +bool js_register_spine_ShearTimeline(se::Object* obj) { + auto* cls = se::Class::create("ShearTimeline", obj, __jsb_spine_TranslateTimeline_proto, _SE(js_new_spine_ShearTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_ShearTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_ShearTimeline_proto = cls->getProto(); + __jsb_spine_ShearTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Skeleton_class = nullptr; +se::Object* __jsb_spine_Skeleton_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skeleton) + +static bool js_new_spine_Skeleton(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Skeleton *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Skeleton *)new spine::Skeleton(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Skeleton, __jsb_spine_Skeleton_class, js_delete_spine_Skeleton) + +static bool js_delete_spine_Skeleton(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skeleton) + +static bool js_spine_Skeleton_updateCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateCache(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_updateCache) + +static bool js_spine_Skeleton_printUpdateCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->printUpdateCache(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_printUpdateCache) + +static bool js_spine_Skeleton_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_updateWorldTransform) + +static bool js_spine_Skeleton_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setToSetupPose) + +static bool js_spine_Skeleton_setBonesToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setBonesToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setBonesToSetupPose) + +static bool js_spine_Skeleton_setSlotsToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setSlotsToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setSlotsToSetupPose) + +static bool js_spine_Skeleton_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Bone *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(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 = (spine::Bone *)(arg1)->findBone((spine::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_spine_Skeleton_findBone) + +static bool js_spine_Skeleton_findBoneIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findBoneIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_findBoneIndex) + +static bool js_spine_Skeleton_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Slot *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(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 = (spine::Slot *)(arg1)->findSlot((spine::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_spine_Skeleton_findSlot) + +static bool js_spine_Skeleton_findSlotIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findSlotIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_findSlotIndex) + +static bool js_spine_Skeleton_setSkinByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSkin((spine::String const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setSkinByName) + +static bool js_spine_Skeleton_getAttachment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String *arg3 = 0 ; + spine::String temp2 ; + spine::String temp3 ; + spine::Attachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *)(arg1)->getAttachment((spine::String const &)*arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Skeleton_getAttachment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + int arg2 ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::Attachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::Attachment *)(arg1)->getAttachment(arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_Skeleton_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_spine_Skeleton_getAttachment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_spine_Skeleton_getAttachment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_Skeleton_getAttachment) + +static bool js_spine_Skeleton_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String *arg3 = 0 ; + spine::String temp2 ; + spine::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(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)->setAttachment((spine::String const &)*arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setAttachment) + +static bool js_spine_Skeleton_findIkConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::IkConstraint *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(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 = (spine::IkConstraint *)(arg1)->findIkConstraint((spine::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_spine_Skeleton_findIkConstraint) + +static bool js_spine_Skeleton_findTransformConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::TransformConstraint *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(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 = (spine::TransformConstraint *)(arg1)->findTransformConstraint((spine::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_spine_Skeleton_findTransformConstraint) + +static bool js_spine_Skeleton_findPathConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::PathConstraint *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(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 = (spine::PathConstraint *)(arg1)->findPathConstraint((spine::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_spine_Skeleton_findPathConstraint) + +static bool js_spine_Skeleton_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_update) + +static bool js_spine_Skeleton_getRootBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Bone *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(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)(arg1)->getRootBone(); + + 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_spine_Skeleton_getRootBone) + +static bool js_spine_Skeleton_setPosition(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + float arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setPosition(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_setPosition) + +static bool js_spine_Skeleton_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::SkeletonData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SkeletonData *)spine_Skeleton_data_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_data_get) + +static bool js_spine_Skeleton_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_Skeleton_bones_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_spine_Skeleton_bones_get) + +static bool js_spine_Skeleton_slots_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Slot * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Slot * > *) &spine_Skeleton_slots_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_spine_Skeleton_slots_get) + +static bool js_spine_Skeleton_drawOrder_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Slot * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Slot * > *) &spine_Skeleton_drawOrder_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_spine_Skeleton_drawOrder_get) + +static bool js_spine_Skeleton_ikConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::IkConstraint * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::IkConstraint * > *) &spine_Skeleton_ikConstraints_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_spine_Skeleton_ikConstraints_get) + +static bool js_spine_Skeleton_transformConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::TransformConstraint * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::TransformConstraint * > *) &spine_Skeleton_transformConstraints_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_spine_Skeleton_transformConstraints_get) + +static bool js_spine_Skeleton_pathConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::PathConstraint * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::PathConstraint * > *) &spine_Skeleton_pathConstraints_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_spine_Skeleton_pathConstraints_get) + +static bool js_spine_Skeleton__updateCache_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Vector< spine::Updatable * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Updatable * > *) &spine_Skeleton__updateCache_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_spine_Skeleton__updateCache_get) + +static bool js_spine_Skeleton_skin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_skin_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_skin_set) + +static bool js_spine_Skeleton_skin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Skin *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Skin *)spine_Skeleton_skin_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_spine_Skeleton_skin_get) + +static bool js_spine_Skeleton_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_Skeleton_color_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_spine_Skeleton_color_get) + +static bool js_spine_Skeleton_time_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_time_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_time_set) + +static bool js_spine_Skeleton_time_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_time_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_time_get) + +static bool js_spine_Skeleton_scaleX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_scaleX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_scaleX_set) + +static bool js_spine_Skeleton_scaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_scaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_scaleX_get) + +static bool js_spine_Skeleton_scaleY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_scaleY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_scaleY_set) + +static bool js_spine_Skeleton_scaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_scaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_scaleY_get) + +static bool js_spine_Skeleton_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_x_set) + +static bool js_spine_Skeleton_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_x_get) + +static bool js_spine_Skeleton_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Skeleton_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skeleton_y_set) + +static bool js_spine_Skeleton_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_Skeleton_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skeleton_y_get) + +static bool js_spine_Skeleton_getAttachmentByName(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *) &spine_Skeleton_getAttachmentByName(arg1,(std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skeleton_getAttachmentByName) + +bool js_register_spine_Skeleton(se::Object* obj) { + auto* cls = se::Class::create("Skeleton", obj, nullptr, _SE(js_new_spine_Skeleton)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Skeleton_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_Skeleton_bones_get), nullptr); + cls->defineProperty("slots", _SE(js_spine_Skeleton_slots_get), nullptr); + cls->defineProperty("drawOrder", _SE(js_spine_Skeleton_drawOrder_get), nullptr); + cls->defineProperty("ikConstraints", _SE(js_spine_Skeleton_ikConstraints_get), nullptr); + cls->defineProperty("transformConstraints", _SE(js_spine_Skeleton_transformConstraints_get), nullptr); + cls->defineProperty("pathConstraints", _SE(js_spine_Skeleton_pathConstraints_get), nullptr); + cls->defineProperty("_updateCache", _SE(js_spine_Skeleton__updateCache_get), nullptr); + cls->defineProperty("skin", _SE(js_spine_Skeleton_skin_get), _SE(js_spine_Skeleton_skin_set)); + cls->defineProperty("color", _SE(js_spine_Skeleton_color_get), nullptr); + cls->defineProperty("time", _SE(js_spine_Skeleton_time_get), _SE(js_spine_Skeleton_time_set)); + cls->defineProperty("scaleX", _SE(js_spine_Skeleton_scaleX_get), _SE(js_spine_Skeleton_scaleX_set)); + cls->defineProperty("scaleY", _SE(js_spine_Skeleton_scaleY_get), _SE(js_spine_Skeleton_scaleY_set)); + cls->defineProperty("x", _SE(js_spine_Skeleton_x_get), _SE(js_spine_Skeleton_x_set)); + cls->defineProperty("y", _SE(js_spine_Skeleton_y_get), _SE(js_spine_Skeleton_y_set)); + + cls->defineFunction("updateCache", _SE(js_spine_Skeleton_updateCache)); + cls->defineFunction("printUpdateCache", _SE(js_spine_Skeleton_printUpdateCache)); + cls->defineFunction("updateWorldTransform", _SE(js_spine_Skeleton_updateWorldTransform)); + cls->defineFunction("setToSetupPose", _SE(js_spine_Skeleton_setToSetupPose)); + cls->defineFunction("setBonesToSetupPose", _SE(js_spine_Skeleton_setBonesToSetupPose)); + cls->defineFunction("setSlotsToSetupPose", _SE(js_spine_Skeleton_setSlotsToSetupPose)); + cls->defineFunction("findBone", _SE(js_spine_Skeleton_findBone)); + cls->defineFunction("findBoneIndex", _SE(js_spine_Skeleton_findBoneIndex)); + cls->defineFunction("findSlot", _SE(js_spine_Skeleton_findSlot)); + cls->defineFunction("findSlotIndex", _SE(js_spine_Skeleton_findSlotIndex)); + cls->defineFunction("setSkinByName", _SE(js_spine_Skeleton_setSkinByName)); + cls->defineFunction("getAttachment", _SE(js_spine_Skeleton_getAttachment)); + cls->defineFunction("setAttachment", _SE(js_spine_Skeleton_setAttachment)); + cls->defineFunction("findIkConstraint", _SE(js_spine_Skeleton_findIkConstraint)); + cls->defineFunction("findTransformConstraint", _SE(js_spine_Skeleton_findTransformConstraint)); + cls->defineFunction("findPathConstraint", _SE(js_spine_Skeleton_findPathConstraint)); + cls->defineFunction("update", _SE(js_spine_Skeleton_update)); + cls->defineFunction("getRootBone", _SE(js_spine_Skeleton_getRootBone)); + cls->defineFunction("setPosition", _SE(js_spine_Skeleton_setPosition)); + cls->defineFunction("getAttachmentByName", _SE(js_spine_Skeleton_getAttachmentByName)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skeleton)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skeleton_proto = cls->getProto(); + __jsb_spine_Skeleton_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Slot_class = nullptr; +se::Object* __jsb_spine_Slot_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Slot) + +static bool js_spine_Slot_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_setToSetupPose) + +static bool js_spine_Slot_getSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Skeleton *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(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *) &(arg1)->getSkeleton(); + + 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_spine_Slot_getSkeleton) + +static bool js_spine_Slot_hasDarkColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->hasDarkColor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_hasDarkColor) + +static bool js_spine_Slot_getAttachmentState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getAttachmentState(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_getAttachmentState) + +static bool js_spine_Slot_setAttachmentState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + int arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachmentState(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_setAttachmentState) + +static bool js_spine_Slot_getAttachmentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getAttachmentTime(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_getAttachmentTime) + +static bool js_spine_Slot_setAttachmentTime(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachmentTime(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Slot_setAttachmentTime) + +static bool js_spine_Slot_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::SlotData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::SlotData *) &spine_Slot_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Slot_data_get) + +static bool js_spine_Slot_bone_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *) &spine_Slot_bone_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_spine_Slot_bone_get) + +static bool js_spine_Slot_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_Slot_color_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_spine_Slot_color_get) + +static bool js_spine_Slot_darkColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_Slot_darkColor_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_spine_Slot_darkColor_get) + +static bool js_spine_Slot_attachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Attachment *arg2 = (spine::Attachment *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_Slot_attachment_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Slot_attachment_set) + +static bool js_spine_Slot_attachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Attachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Attachment *)spine_Slot_attachment_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_spine_Slot_attachment_get) + +static bool js_spine_Slot_deform_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Slot *arg1 = (spine::Slot *) NULL ; + spine::Vector< float > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< float > *) &spine_Slot_deform_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_spine_Slot_deform_get) + +static bool js_new_spine_Slot(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + spine::Slot *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Slot *)new_spine_Slot(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Slot, __jsb_spine_Slot_class, js_delete_spine_Slot) + +static bool js_delete_spine_Slot(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Slot) + +bool js_register_spine_Slot(se::Object* obj) { + auto* cls = se::Class::create("Slot", obj, nullptr, _SE(js_new_spine_Slot)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_Slot_data_get), nullptr); + cls->defineProperty("bone", _SE(js_spine_Slot_bone_get), nullptr); + cls->defineProperty("color", _SE(js_spine_Slot_color_get), nullptr); + cls->defineProperty("darkColor", _SE(js_spine_Slot_darkColor_get), nullptr); + cls->defineProperty("attachment", _SE(js_spine_Slot_attachment_get), _SE(js_spine_Slot_attachment_set)); + cls->defineProperty("deform", _SE(js_spine_Slot_deform_get), nullptr); + + cls->defineFunction("setToSetupPose", _SE(js_spine_Slot_setToSetupPose)); + cls->defineFunction("getSkeleton", _SE(js_spine_Slot_getSkeleton)); + cls->defineFunction("hasDarkColor", _SE(js_spine_Slot_hasDarkColor)); + cls->defineFunction("getAttachmentState", _SE(js_spine_Slot_getAttachmentState)); + cls->defineFunction("setAttachmentState", _SE(js_spine_Slot_setAttachmentState)); + cls->defineFunction("getAttachmentTime", _SE(js_spine_Slot_getAttachmentTime)); + cls->defineFunction("setAttachmentTime", _SE(js_spine_Slot_setAttachmentTime)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Slot)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Slot_proto = cls->getProto(); + __jsb_spine_Slot_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Skin_class = nullptr; +se::Object* __jsb_spine_Skin_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin) + +se::Class* __jsb_spine_Skin_AttachmentMap_class = nullptr; +se::Object* __jsb_spine_Skin_AttachmentMap_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap) + +se::Class* __jsb_spine_Skin_AttachmentMap_Entry_class = nullptr; +se::Object* __jsb_spine_Skin_AttachmentMap_Entry_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entry) + +static bool js_spine_Skin_AttachmentMap_Entry_slotIndex_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_slotIndex, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skin_AttachmentMap_Entry_slotIndex_set) + +static bool js_spine_Skin_AttachmentMap_Entry_slotIndex_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_slotIndex, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skin_AttachmentMap_Entry_slotIndex_get) + +static bool js_spine_Skin_AttachmentMap_Entry_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skin_AttachmentMap_Entry_name_set) + +static bool js_spine_Skin_AttachmentMap_Entry_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skin_AttachmentMap_Entry_name_get) + +static bool js_spine_Skin_AttachmentMap_Entry_attachment_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_attachment, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Skin_AttachmentMap_Entry_attachment_set) + +static bool js_spine_Skin_AttachmentMap_Entry_attachment_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin::AttachmentMap::Entry *arg1 = (spine::Skin::AttachmentMap::Entry *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_attachment, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->_attachment, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Skin_AttachmentMap_Entry_attachment_get) + +static bool js_new_spine_Skin_AttachmentMap_Entry(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + size_t arg1 ; + spine::String *arg2 = 0 ; + spine::Attachment *arg3 = (spine::Attachment *) NULL ; + spine::String temp2 ; + spine::Skin::AttachmentMap::Entry *result; + + 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; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Skin::AttachmentMap::Entry *)new spine::Skin::AttachmentMap::Entry(arg1,(spine::String const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Skin_AttachmentMap_Entry, __jsb_spine_Skin_AttachmentMap_Entry_class, js_delete_spine_Skin_AttachmentMap_Entry) + +static bool js_delete_spine_Skin_AttachmentMap_Entry(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entry) + +template<> +bool sevalue_to_native(const se::Value &from, spine::Skin::AttachmentMap::Entry * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("slotIndex", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_slotIndex), ctx); + } + + + json->getProperty("name", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_name), ctx); + } + + + json->getProperty("attachment", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->_attachment), ctx); + } + + + return ok; +} + + +bool js_register_spine_Skin_AttachmentMap_Entry(se::Object* obj) { + auto* cls = se::Class::create({"Skin", "AttachmentMap", "Entry"}, obj, nullptr, _SE(js_new_spine_Skin_AttachmentMap_Entry)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("slotIndex", _SE(js_spine_Skin_AttachmentMap_Entry_slotIndex_get), _SE(js_spine_Skin_AttachmentMap_Entry_slotIndex_set)); + cls->defineProperty("name", _SE(js_spine_Skin_AttachmentMap_Entry_name_get), _SE(js_spine_Skin_AttachmentMap_Entry_name_set)); + cls->defineProperty("attachment", _SE(js_spine_Skin_AttachmentMap_Entry_attachment_get), _SE(js_spine_Skin_AttachmentMap_Entry_attachment_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin_AttachmentMap_Entry)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_AttachmentMap_Entry_proto = cls->getProto(); + __jsb_spine_Skin_AttachmentMap_Entry_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Skin_AttachmentMap_Entries_class = nullptr; +se::Object* __jsb_spine_Skin_AttachmentMap_Entries_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entries) + +static bool js_spine_Skin_AttachmentMap_Entries_hasNext(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entries *arg1 = (spine::Skin::AttachmentMap::Entries *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->hasNext(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_Entries_hasNext) + +static bool js_spine_Skin_AttachmentMap_Entries_next(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap::Entries *arg1 = (spine::Skin::AttachmentMap::Entries *) NULL ; + spine::Skin::AttachmentMap::Entry *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(s); + if (nullptr == arg1) return true; + result = (spine::Skin::AttachmentMap::Entry *) &(arg1)->next(); + + 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_spine_Skin_AttachmentMap_Entries_next) + +static bool js_delete_spine_Skin_AttachmentMap_Entries(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap_Entries) + +bool js_register_spine_Skin_AttachmentMap_Entries(se::Object* obj) { + auto* cls = se::Class::create({"Skin", "AttachmentMap", "Entries"}, obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("hasNext", _SE(js_spine_Skin_AttachmentMap_Entries_hasNext)); + cls->defineFunction("next", _SE(js_spine_Skin_AttachmentMap_Entries_next)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin_AttachmentMap_Entries)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_AttachmentMap_Entries_proto = cls->getProto(); + __jsb_spine_Skin_AttachmentMap_Entries_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_spine_Skin_AttachmentMap_put(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap *arg1 = (spine::Skin::AttachmentMap *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::Attachment *arg4 = (spine::Attachment *) NULL ; + spine::String temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->put(arg2,(spine::String const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_put) + +static bool js_spine_Skin_AttachmentMap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap *arg1 = (spine::Skin::AttachmentMap *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::Attachment *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(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 = (spine::Attachment *)(arg1)->get(arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_get) + +static bool js_spine_Skin_AttachmentMap_remove(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin::AttachmentMap *arg1 = (spine::Skin::AttachmentMap *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->remove(arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_AttachmentMap_remove) + +static bool js_delete_spine_Skin_AttachmentMap(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin_AttachmentMap) + +bool js_register_spine_Skin_AttachmentMap(se::Object* obj) { + auto* cls = se::Class::create({"Skin", "AttachmentMap"}, obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("put", _SE(js_spine_Skin_AttachmentMap_put)); + cls->defineFunction("get", _SE(js_spine_Skin_AttachmentMap_get)); + cls->defineFunction("remove", _SE(js_spine_Skin_AttachmentMap_remove)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin_AttachmentMap)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_AttachmentMap_proto = cls->getProto(); + __jsb_spine_Skin_AttachmentMap_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +static bool js_new_spine_Skin(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::Skin *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::Skin *)new spine::Skin((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_Skin, __jsb_spine_Skin_class, js_delete_spine_Skin) + +static bool js_delete_spine_Skin(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Skin) + +static bool js_spine_Skin_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::Attachment *arg4 = (spine::Attachment *) NULL ; + spine::String temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachment(arg2,(spine::String const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_setAttachment) + +static bool js_spine_Skin_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::Attachment *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(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 = (spine::Attachment *)(arg1)->getAttachment(arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_getAttachment) + +static bool js_spine_Skin_removeAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + size_t arg2 ; + spine::String *arg3 = 0 ; + spine::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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->removeAttachment(arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_removeAttachment) + +static bool js_spine_Skin_addSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addSkin(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_addSkin) + +static bool js_spine_Skin_copySkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->copySkin(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_Skin_copySkin) + +static bool js_spine_Skin_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_Skin_name_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_spine_Skin_name_get) + +static bool js_spine_Skin_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_Skin_bones_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_spine_Skin_bones_get) + +static bool js_spine_Skin_constraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Skin *arg1 = (spine::Skin *) NULL ; + spine::Vector< spine::ConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::ConstraintData * > *) &spine_Skin_constraints_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_spine_Skin_constraints_get) + +bool js_register_spine_Skin(se::Object* obj) { + auto* cls = se::Class::create("Skin", obj, nullptr, _SE(js_new_spine_Skin)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_Skin_name_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_Skin_bones_get), nullptr); + cls->defineProperty("constraints", _SE(js_spine_Skin_constraints_get), nullptr); + + cls->defineFunction("setAttachment", _SE(js_spine_Skin_setAttachment)); + cls->defineFunction("getAttachment", _SE(js_spine_Skin_getAttachment)); + cls->defineFunction("removeAttachment", _SE(js_spine_Skin_removeAttachment)); + cls->defineFunction("addSkin", _SE(js_spine_Skin_addSkin)); + cls->defineFunction("copySkin", _SE(js_spine_Skin_copySkin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Skin)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Skin_proto = cls->getProto(); + __jsb_spine_Skin_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SkeletonBounds_class = nullptr; +se::Object* __jsb_spine_SkeletonBounds_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SkeletonBounds) + +static bool js_new_spine_SkeletonBounds(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::SkeletonBounds *result; + result = (spine::SkeletonBounds *)new spine::SkeletonBounds(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SkeletonBounds, __jsb_spine_SkeletonBounds_class, js_delete_spine_SkeletonBounds) + +static bool js_delete_spine_SkeletonBounds(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SkeletonBounds) + +static bool js_spine_SkeletonBounds_aabbcontainsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + bool result; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (bool)(arg1)->aabbcontainsPoint(arg2,arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_aabbcontainsPoint) + +static bool js_spine_SkeletonBounds_aabbintersectsSegment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + bool result; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->aabbintersectsSegment(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_aabbintersectsSegment) + +static bool js_spine_SkeletonBounds_aabbIntersectsSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::SkeletonBounds arg2 ; + bool result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->aabbIntersectsSkeleton(arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_aabbIntersectsSkeleton) + +static bool js_spine_SkeletonBounds_containsPoint__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::Polygon *arg2 = (spine::Polygon *) NULL ; + float arg3 ; + float arg4 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->containsPoint(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_SkeletonBounds_containsPoint__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + spine::BoundingBoxAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::BoundingBoxAttachment *)(arg1)->containsPoint(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_spine_SkeletonBounds_containsPoint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_spine_SkeletonBounds_containsPoint__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_spine_SkeletonBounds_containsPoint__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_containsPoint) + +static bool js_spine_SkeletonBounds_intersectsSegment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + spine::BoundingBoxAttachment *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::BoundingBoxAttachment *)(arg1)->intersectsSegment(arg2,arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_spine_SkeletonBounds_intersectsSegment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::Polygon *arg2 = (spine::Polygon *) NULL ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (bool)(arg1)->intersectsSegment(arg2,arg3,arg4,arg5,arg6); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_spine_SkeletonBounds_intersectsSegment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_spine_SkeletonBounds_intersectsSegment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 5) { + ok = js_spine_SkeletonBounds_intersectsSegment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_intersectsSegment) + +static bool js_spine_SkeletonBounds_getPolygon(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::BoundingBoxAttachment *arg2 = (spine::BoundingBoxAttachment *) NULL ; + spine::Polygon *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Polygon *)(arg1)->getPolygon(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_spine_SkeletonBounds_getPolygon) + +static bool js_spine_SkeletonBounds_getWidth(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWidth(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_getWidth) + +static bool js_spine_SkeletonBounds_getHeight(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getHeight(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_getHeight) + +static bool js_spine_SkeletonBounds_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBounds *arg1 = (spine::SkeletonBounds *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonBounds_update(arg1,arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonBounds_update) + +bool js_register_spine_SkeletonBounds(se::Object* obj) { + auto* cls = se::Class::create("SkeletonBounds", obj, nullptr, _SE(js_new_spine_SkeletonBounds)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("aabbcontainsPoint", _SE(js_spine_SkeletonBounds_aabbcontainsPoint)); + cls->defineFunction("aabbintersectsSegment", _SE(js_spine_SkeletonBounds_aabbintersectsSegment)); + cls->defineFunction("aabbIntersectsSkeleton", _SE(js_spine_SkeletonBounds_aabbIntersectsSkeleton)); + cls->defineFunction("containsPoint", _SE(js_spine_SkeletonBounds_containsPoint)); + cls->defineFunction("intersectsSegment", _SE(js_spine_SkeletonBounds_intersectsSegment)); + cls->defineFunction("getPolygon", _SE(js_spine_SkeletonBounds_getPolygon)); + cls->defineFunction("getWidth", _SE(js_spine_SkeletonBounds_getWidth)); + cls->defineFunction("getHeight", _SE(js_spine_SkeletonBounds_getHeight)); + cls->defineFunction("update", _SE(js_spine_SkeletonBounds_update)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SkeletonBounds)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SkeletonBounds_proto = cls->getProto(); + __jsb_spine_SkeletonBounds_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Polygon_class = nullptr; +se::Object* __jsb_spine_Polygon_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Polygon) + +static bool js_spine_Polygon__count_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Polygon *arg1 = (spine::Polygon *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->_count, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_Polygon__count_set) + +static bool js_spine_Polygon__count_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::Polygon *arg1 = (spine::Polygon *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->_count, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_Polygon__count_get) + +static bool js_delete_spine_Polygon(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Polygon) + +bool js_register_spine_Polygon(se::Object* obj) { + auto* cls = se::Class::create("Polygon", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("_count", _SE(js_spine_Polygon__count_get), _SE(js_spine_Polygon__count_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Polygon)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Polygon_proto = cls->getProto(); + __jsb_spine_Polygon_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SkeletonData_class = nullptr; +se::Object* __jsb_spine_SkeletonData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SkeletonData) + +static bool js_new_spine_SkeletonData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::SkeletonData *result; + result = (spine::SkeletonData *)new spine::SkeletonData(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SkeletonData, __jsb_spine_SkeletonData_class, js_delete_spine_SkeletonData) + +static bool js_delete_spine_SkeletonData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SkeletonData) + +static bool js_spine_SkeletonData_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::BoneData *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(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 = (spine::BoneData *)(arg1)->findBone((spine::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_spine_SkeletonData_findBone) + +static bool js_spine_SkeletonData_findBoneIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findBoneIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonData_findBoneIndex) + +static bool js_spine_SkeletonData_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::SlotData *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(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 = (spine::SlotData *)(arg1)->findSlot((spine::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_spine_SkeletonData_findSlot) + +static bool js_spine_SkeletonData_findSlotIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findSlotIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonData_findSlotIndex) + +static bool js_spine_SkeletonData_findSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Skin *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(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 = (spine::Skin *)(arg1)->findSkin((spine::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_spine_SkeletonData_findSkin) + +static bool js_spine_SkeletonData_findEvent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::EventData *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(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 = (spine::EventData *)(arg1)->findEvent((spine::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_spine_SkeletonData_findEvent) + +static bool js_spine_SkeletonData_findAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::Animation *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(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 = (spine::Animation *)(arg1)->findAnimation((spine::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_spine_SkeletonData_findAnimation) + +static bool js_spine_SkeletonData_findIkConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::IkConstraintData *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(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 = (spine::IkConstraintData *)(arg1)->findIkConstraint((spine::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_spine_SkeletonData_findIkConstraint) + +static bool js_spine_SkeletonData_findTransformConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::TransformConstraintData *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(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 = (spine::TransformConstraintData *)(arg1)->findTransformConstraint((spine::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_spine_SkeletonData_findTransformConstraint) + +static bool js_spine_SkeletonData_findPathConstraint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::PathConstraintData *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(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 = (spine::PathConstraintData *)(arg1)->findPathConstraint((spine::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_spine_SkeletonData_findPathConstraint) + +static bool js_spine_SkeletonData_findPathConstraintIndex(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + int result; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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 = (int)(arg1)->findPathConstraintIndex((spine::String const &)*arg2); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SkeletonData_findPathConstraintIndex) + +static bool js_spine_SkeletonData_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_name_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_name_set) + +static bool js_spine_SkeletonData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_name_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_spine_SkeletonData_name_get) + +static bool js_spine_SkeletonData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_SkeletonData_bones_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_spine_SkeletonData_bones_get) + +static bool js_spine_SkeletonData_slots_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::SlotData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::SlotData * > *) &spine_SkeletonData_slots_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_spine_SkeletonData_slots_get) + +static bool js_spine_SkeletonData_skins_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::Skin * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Skin * > *) &spine_SkeletonData_skins_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_spine_SkeletonData_skins_get) + +static bool js_spine_SkeletonData_defaultSkin_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_defaultSkin_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_defaultSkin_set) + +static bool js_spine_SkeletonData_defaultSkin_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Skin *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Skin *)spine_SkeletonData_defaultSkin_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_spine_SkeletonData_defaultSkin_get) + +static bool js_spine_SkeletonData_events_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::EventData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::EventData * > *) &spine_SkeletonData_events_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_spine_SkeletonData_events_get) + +static bool js_spine_SkeletonData_animations_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::Animation * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Animation * > *) &spine_SkeletonData_animations_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_spine_SkeletonData_animations_get) + +static bool js_spine_SkeletonData_ikConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::IkConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::IkConstraintData * > *) &spine_SkeletonData_ikConstraints_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_spine_SkeletonData_ikConstraints_get) + +static bool js_spine_SkeletonData_transformConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::TransformConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::TransformConstraintData * > *) &spine_SkeletonData_transformConstraints_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_spine_SkeletonData_transformConstraints_get) + +static bool js_spine_SkeletonData_pathConstraints_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::Vector< spine::PathConstraintData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::PathConstraintData * > *) &spine_SkeletonData_pathConstraints_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_spine_SkeletonData_pathConstraints_get) + +static bool js_spine_SkeletonData_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_x_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_x_set) + +static bool js_spine_SkeletonData_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_x_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_x_get) + +static bool js_spine_SkeletonData_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_y_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_y_set) + +static bool js_spine_SkeletonData_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_y_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_y_get) + +static bool js_spine_SkeletonData_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_width_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_width_set) + +static bool js_spine_SkeletonData_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_width_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_width_get) + +static bool js_spine_SkeletonData_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_height_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_height_set) + +static bool js_spine_SkeletonData_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_height_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_height_get) + +static bool js_spine_SkeletonData_version_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_version_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_version_set) + +static bool js_spine_SkeletonData_version_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_version_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_spine_SkeletonData_version_get) + +static bool js_spine_SkeletonData_hash_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_hash_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_hash_set) + +static bool js_spine_SkeletonData_hash_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_hash_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_spine_SkeletonData_hash_get) + +static bool js_spine_SkeletonData_fps_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonData_fps_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_fps_set) + +static bool js_spine_SkeletonData_fps_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SkeletonData_fps_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SkeletonData_fps_get) + +static bool js_spine_SkeletonData_imagesPath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_imagesPath_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_imagesPath_set) + +static bool js_spine_SkeletonData_imagesPath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_imagesPath_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_spine_SkeletonData_imagesPath_get) + +static bool js_spine_SkeletonData_audioPath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SkeletonData_audioPath_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonData_audioPath_set) + +static bool js_spine_SkeletonData_audioPath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SkeletonData_audioPath_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_spine_SkeletonData_audioPath_get) + +bool js_register_spine_SkeletonData(se::Object* obj) { + auto* cls = se::Class::create("SkeletonData", obj, nullptr, _SE(js_new_spine_SkeletonData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_SkeletonData_name_get), _SE(js_spine_SkeletonData_name_set)); + cls->defineProperty("bones", _SE(js_spine_SkeletonData_bones_get), nullptr); + cls->defineProperty("slots", _SE(js_spine_SkeletonData_slots_get), nullptr); + cls->defineProperty("skins", _SE(js_spine_SkeletonData_skins_get), nullptr); + cls->defineProperty("defaultSkin", _SE(js_spine_SkeletonData_defaultSkin_get), _SE(js_spine_SkeletonData_defaultSkin_set)); + cls->defineProperty("events", _SE(js_spine_SkeletonData_events_get), nullptr); + cls->defineProperty("animations", _SE(js_spine_SkeletonData_animations_get), nullptr); + cls->defineProperty("ikConstraints", _SE(js_spine_SkeletonData_ikConstraints_get), nullptr); + cls->defineProperty("transformConstraints", _SE(js_spine_SkeletonData_transformConstraints_get), nullptr); + cls->defineProperty("pathConstraints", _SE(js_spine_SkeletonData_pathConstraints_get), nullptr); + cls->defineProperty("x", _SE(js_spine_SkeletonData_x_get), _SE(js_spine_SkeletonData_x_set)); + cls->defineProperty("y", _SE(js_spine_SkeletonData_y_get), _SE(js_spine_SkeletonData_y_set)); + cls->defineProperty("width", _SE(js_spine_SkeletonData_width_get), _SE(js_spine_SkeletonData_width_set)); + cls->defineProperty("height", _SE(js_spine_SkeletonData_height_get), _SE(js_spine_SkeletonData_height_set)); + cls->defineProperty("version", _SE(js_spine_SkeletonData_version_get), _SE(js_spine_SkeletonData_version_set)); + cls->defineProperty("hash", _SE(js_spine_SkeletonData_hash_get), _SE(js_spine_SkeletonData_hash_set)); + cls->defineProperty("fps", _SE(js_spine_SkeletonData_fps_get), _SE(js_spine_SkeletonData_fps_set)); + cls->defineProperty("imagesPath", _SE(js_spine_SkeletonData_imagesPath_get), _SE(js_spine_SkeletonData_imagesPath_set)); + cls->defineProperty("audioPath", _SE(js_spine_SkeletonData_audioPath_get), _SE(js_spine_SkeletonData_audioPath_set)); + + cls->defineFunction("findBone", _SE(js_spine_SkeletonData_findBone)); + cls->defineFunction("findBoneIndex", _SE(js_spine_SkeletonData_findBoneIndex)); + cls->defineFunction("findSlot", _SE(js_spine_SkeletonData_findSlot)); + cls->defineFunction("findSlotIndex", _SE(js_spine_SkeletonData_findSlotIndex)); + cls->defineFunction("findSkin", _SE(js_spine_SkeletonData_findSkin)); + cls->defineFunction("findEvent", _SE(js_spine_SkeletonData_findEvent)); + cls->defineFunction("findAnimation", _SE(js_spine_SkeletonData_findAnimation)); + cls->defineFunction("findIkConstraint", _SE(js_spine_SkeletonData_findIkConstraint)); + cls->defineFunction("findTransformConstraint", _SE(js_spine_SkeletonData_findTransformConstraint)); + cls->defineFunction("findPathConstraint", _SE(js_spine_SkeletonData_findPathConstraint)); + cls->defineFunction("findPathConstraintIndex", _SE(js_spine_SkeletonData_findPathConstraintIndex)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SkeletonData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SkeletonData_proto = cls->getProto(); + __jsb_spine_SkeletonData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SlotData_class = nullptr; +se::Object* __jsb_spine_SlotData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SlotData) + +static bool js_spine_SlotData_hasDarkColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) 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(s); + if (nullptr == arg1) return true; + result = (bool)(arg1)->hasDarkColor(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SlotData_hasDarkColor) + +static bool js_spine_SlotData_setHasDarkColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setHasDarkColor(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_SlotData_setHasDarkColor) + +static bool js_spine_SlotData_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + int result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)spine_SlotData_index_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SlotData_index_get) + +static bool js_spine_SlotData_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SlotData_name_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_spine_SlotData_name_get) + +static bool js_spine_SlotData_boneData_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *) &spine_SlotData_boneData_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_spine_SlotData_boneData_get) + +static bool js_spine_SlotData_color_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_SlotData_color_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_spine_SlotData_color_get) + +static bool js_spine_SlotData_darkColor_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::Color *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Color *) &spine_SlotData_darkColor_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_spine_SlotData_darkColor_get) + +static bool js_spine_SlotData_attachmentName_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + spine_SlotData_attachmentName_set(arg1,*arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SlotData_attachmentName_set) + +static bool js_spine_SlotData_attachmentName_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::String *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::String *) &spine_SlotData_attachmentName_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_spine_SlotData_attachmentName_get) + +static bool js_spine_SlotData_blendMode_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::BlendMode arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + spine_SlotData_blendMode_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SlotData_blendMode_set) + +static bool js_spine_SlotData_blendMode_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SlotData *arg1 = (spine::SlotData *) NULL ; + spine::BlendMode result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BlendMode)spine_SlotData_blendMode_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_spine_SlotData_blendMode_get) + +static bool js_new_spine_SlotData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + + int arg1 ; + ccstd::string *arg2 = (ccstd::string *) NULL ; + spine::BoneData *arg3 = (spine::BoneData *) NULL ; + spine::SlotData *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SlotData *)new_spine_SlotData(arg1,(ccstd::string const *)arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SlotData, __jsb_spine_SlotData_class, js_delete_spine_SlotData) + +static bool js_delete_spine_SlotData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SlotData) + +bool js_register_spine_SlotData(se::Object* obj) { + auto* cls = se::Class::create("SlotData", obj, nullptr, _SE(js_new_spine_SlotData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("index", _SE(js_spine_SlotData_index_get), nullptr); + cls->defineProperty("name", _SE(js_spine_SlotData_name_get), nullptr); + cls->defineProperty("boneData", _SE(js_spine_SlotData_boneData_get), nullptr); + cls->defineProperty("color", _SE(js_spine_SlotData_color_get), nullptr); + cls->defineProperty("darkColor", _SE(js_spine_SlotData_darkColor_get), nullptr); + cls->defineProperty("attachmentName", _SE(js_spine_SlotData_attachmentName_get), _SE(js_spine_SlotData_attachmentName_set)); + cls->defineProperty("blendMode", _SE(js_spine_SlotData_blendMode_get), _SE(js_spine_SlotData_blendMode_set)); + + cls->defineFunction("hasDarkColor", _SE(js_spine_SlotData_hasDarkColor)); + cls->defineFunction("setHasDarkColor", _SE(js_spine_SlotData_setHasDarkColor)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SlotData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SlotData_proto = cls->getProto(); + __jsb_spine_SlotData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SkeletonBinary_class = nullptr; +se::Object* __jsb_spine_SkeletonBinary_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SkeletonBinary) + +static bool js_new_spine_SkeletonBinary__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + spine::SkeletonBinary *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SkeletonBinary *)new spine::SkeletonBinary(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_SkeletonBinary__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::SkeletonBinary *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SkeletonBinary *)new spine::SkeletonBinary(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_SkeletonBinary(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 1) { + ret = js_new_spine_SkeletonBinary__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_spine_SkeletonBinary__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of SkeletonBinary"); + return false; +} +SE_BIND_CTOR(js_new_spine_SkeletonBinary, __jsb_spine_SkeletonBinary_class, js_delete_spine_SkeletonBinary) + +static bool js_delete_spine_SkeletonBinary(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SkeletonBinary) + +static bool js_spine_SkeletonBinary_readSkeletonDataFile(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::SkeletonData *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(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 = (spine::SkeletonData *)(arg1)->readSkeletonDataFile((spine::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_spine_SkeletonBinary_readSkeletonDataFile) + +static bool js_spine_SkeletonBinary_getError(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + spine::String *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(s); + if (nullptr == arg1) return true; + result = (spine::String *) &(arg1)->getError(); + + 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_spine_SkeletonBinary_getError) + +static bool js_spine_SkeletonBinary_scale_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SkeletonBinary_scale_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SkeletonBinary_scale_set) + +static bool js_spine_SkeletonBinary_readSkeletonData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SkeletonBinary *arg1 = (spine::SkeletonBinary *) NULL ; + std::vector< uint8_t > *arg2 = 0 ; + std::vector< uint8_t > temp2 ; + spine::SkeletonData *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(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 = (spine::SkeletonData *)spine_SkeletonBinary_readSkeletonData(arg1,(std::vector< uint8_t > 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_spine_SkeletonBinary_readSkeletonData) + +bool js_register_spine_SkeletonBinary(se::Object* obj) { + auto* cls = se::Class::create("SkeletonBinary", obj, nullptr, _SE(js_new_spine_SkeletonBinary)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("scale", nullptr, _SE(js_spine_SkeletonBinary_scale_set)); + + cls->defineFunction("readSkeletonDataFile", _SE(js_spine_SkeletonBinary_readSkeletonDataFile)); + cls->defineFunction("getError", _SE(js_spine_SkeletonBinary_getError)); + cls->defineFunction("readSkeletonData", _SE(js_spine_SkeletonBinary_readSkeletonData)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SkeletonBinary)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SkeletonBinary_proto = cls->getProto(); + __jsb_spine_SkeletonBinary_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AttachmentLoader_class = nullptr; +se::Object* __jsb_spine_AttachmentLoader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AttachmentLoader) + +static bool js_delete_spine_AttachmentLoader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AttachmentLoader) + +static bool js_spine_AttachmentLoader_configureAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Attachment *arg2 = (spine::Attachment *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->configureAttachment(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_configureAttachment) + +static bool js_spine_AttachmentLoader_newRegionAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String *arg4 = 0 ; + spine::String temp3 ; + spine::String temp4 ; + spine::RegionAttachment *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (spine::RegionAttachment *)spine_AttachmentLoader_newRegionAttachment(arg1,arg2,(spine::String const &)*arg3,(spine::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; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newRegionAttachment) + +static bool js_spine_AttachmentLoader_newMeshAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String *arg4 = 0 ; + spine::String temp3 ; + spine::String temp4 ; + spine::MeshAttachment *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &temp4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg4 = &temp4; + + result = (spine::MeshAttachment *)spine_AttachmentLoader_newMeshAttachment(arg1,arg2,(spine::String const &)*arg3,(spine::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; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newMeshAttachment) + +static bool js_spine_AttachmentLoader_newBoundingBoxAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::BoundingBoxAttachment *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(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 = (spine::BoundingBoxAttachment *)spine_AttachmentLoader_newBoundingBoxAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newBoundingBoxAttachment) + +static bool js_spine_AttachmentLoader_newPathAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::PathAttachment *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(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 = (spine::PathAttachment *)spine_AttachmentLoader_newPathAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newPathAttachment) + +static bool js_spine_AttachmentLoader_newPointAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::PointAttachment *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(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 = (spine::PointAttachment *)spine_AttachmentLoader_newPointAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newPointAttachment) + +static bool js_spine_AttachmentLoader_newClippingAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AttachmentLoader *arg1 = (spine::AttachmentLoader *) NULL ; + spine::Skin *arg2 = (spine::Skin *) NULL ; + spine::String *arg3 = 0 ; + spine::String temp3 ; + spine::ClippingAttachment *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(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 = (spine::ClippingAttachment *)spine_AttachmentLoader_newClippingAttachment(arg1,arg2,(spine::String const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_spine_AttachmentLoader_newClippingAttachment) + +bool js_register_spine_AttachmentLoader(se::Object* obj) { + auto* cls = se::Class::create("AttachmentLoader", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("configureAttachment", _SE(js_spine_AttachmentLoader_configureAttachment)); + cls->defineFunction("newRegionAttachment", _SE(js_spine_AttachmentLoader_newRegionAttachment)); + cls->defineFunction("newMeshAttachment", _SE(js_spine_AttachmentLoader_newMeshAttachment)); + cls->defineFunction("newBoundingBoxAttachment", _SE(js_spine_AttachmentLoader_newBoundingBoxAttachment)); + cls->defineFunction("newPathAttachment", _SE(js_spine_AttachmentLoader_newPathAttachment)); + cls->defineFunction("newPointAttachment", _SE(js_spine_AttachmentLoader_newPointAttachment)); + cls->defineFunction("newClippingAttachment", _SE(js_spine_AttachmentLoader_newClippingAttachment)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AttachmentLoader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AttachmentLoader_proto = cls->getProto(); + __jsb_spine_AttachmentLoader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AtlasPage_class = nullptr; +se::Object* __jsb_spine_AtlasPage_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AtlasPage) + +static bool js_spine_TextureAtlasPage_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_name_set) + +static bool js_spine_TextureAtlasPage_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_name_get) + +static bool js_spine_TextureAtlasPage_texturePath_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->texturePath, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_texturePath_set) + +static bool js_spine_TextureAtlasPage_texturePath_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->texturePath, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->texturePath, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_texturePath_get) + +static bool js_spine_TextureAtlasPage_format_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->format, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_format_set) + +static bool js_spine_TextureAtlasPage_format_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->format, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->format, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_format_get) + +static bool js_spine_TextureAtlasPage_minFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->minFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_minFilter_set) + +static bool js_spine_TextureAtlasPage_minFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->minFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->minFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_minFilter_get) + +static bool js_spine_TextureAtlasPage_magFilter_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->magFilter, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_magFilter_set) + +static bool js_spine_TextureAtlasPage_magFilter_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->magFilter, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->magFilter, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_magFilter_get) + +static bool js_spine_TextureAtlasPage_uWrap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->uWrap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_uWrap_set) + +static bool js_spine_TextureAtlasPage_uWrap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->uWrap, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->uWrap, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_uWrap_get) + +static bool js_spine_TextureAtlasPage_vWrap_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->vWrap, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_vWrap_set) + +static bool js_spine_TextureAtlasPage_vWrap_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->vWrap, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->vWrap, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_vWrap_get) + +static bool js_spine_TextureAtlasPage_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_width_set) + +static bool js_spine_TextureAtlasPage_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_width_get) + +static bool js_spine_TextureAtlasPage_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasPage_height_set) + +static bool js_spine_TextureAtlasPage_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasPage *arg1 = (spine::AtlasPage *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasPage_height_get) + +static bool js_new_spine_AtlasPage(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::AtlasPage *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::AtlasPage *)new spine::AtlasPage((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AtlasPage, __jsb_spine_AtlasPage_class, js_delete_spine_AtlasPage) + +static bool js_delete_spine_AtlasPage(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AtlasPage) + +bool js_register_spine_AtlasPage(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlasPage", obj, nullptr, _SE(js_new_spine_AtlasPage)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("name", _SE(js_spine_TextureAtlasPage_name_get), _SE(js_spine_TextureAtlasPage_name_set)); + cls->defineProperty("texturePath", _SE(js_spine_TextureAtlasPage_texturePath_get), _SE(js_spine_TextureAtlasPage_texturePath_set)); + cls->defineProperty("format", _SE(js_spine_TextureAtlasPage_format_get), _SE(js_spine_TextureAtlasPage_format_set)); + cls->defineProperty("minFilter", _SE(js_spine_TextureAtlasPage_minFilter_get), _SE(js_spine_TextureAtlasPage_minFilter_set)); + cls->defineProperty("magFilter", _SE(js_spine_TextureAtlasPage_magFilter_get), _SE(js_spine_TextureAtlasPage_magFilter_set)); + cls->defineProperty("uWrap", _SE(js_spine_TextureAtlasPage_uWrap_get), _SE(js_spine_TextureAtlasPage_uWrap_set)); + cls->defineProperty("vWrap", _SE(js_spine_TextureAtlasPage_vWrap_get), _SE(js_spine_TextureAtlasPage_vWrap_set)); + cls->defineProperty("width", _SE(js_spine_TextureAtlasPage_width_get), _SE(js_spine_TextureAtlasPage_width_set)); + cls->defineProperty("height", _SE(js_spine_TextureAtlasPage_height_get), _SE(js_spine_TextureAtlasPage_height_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AtlasPage)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AtlasPage_proto = cls->getProto(); + __jsb_spine_AtlasPage_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_AtlasRegion_class = nullptr; +se::Object* __jsb_spine_AtlasRegion_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_AtlasRegion) + +static bool js_spine_TextureAtlasRegion_page_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->page, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_page_set) + +static bool js_spine_TextureAtlasRegion_page_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->page, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->page, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_page_get) + +static bool js_spine_TextureAtlasRegion_name_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->name, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_name_set) + +static bool js_spine_TextureAtlasRegion_name_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->name, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->name, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_name_get) + +static bool js_spine_TextureAtlasRegion_x_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->x, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_x_set) + +static bool js_spine_TextureAtlasRegion_x_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->x, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_x_get) + +static bool js_spine_TextureAtlasRegion_y_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->y, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_y_set) + +static bool js_spine_TextureAtlasRegion_y_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->y, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_y_get) + +static bool js_spine_TextureAtlasRegion_width_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->width, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_width_set) + +static bool js_spine_TextureAtlasRegion_width_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->width, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_width_get) + +static bool js_spine_TextureAtlasRegion_height_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->height, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_height_set) + +static bool js_spine_TextureAtlasRegion_height_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->height, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_height_get) + +static bool js_spine_TextureAtlasRegion_u_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->u, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_u_set) + +static bool js_spine_TextureAtlasRegion_u_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->u, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_u_get) + +static bool js_spine_TextureAtlasRegion_v_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_v_set) + +static bool js_spine_TextureAtlasRegion_v_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_v_get) + +static bool js_spine_TextureAtlasRegion_u2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->u2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_u2_set) + +static bool js_spine_TextureAtlasRegion_u2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->u2, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_u2_get) + +static bool js_spine_TextureAtlasRegion_v2_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->v2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_v2_set) + +static bool js_spine_TextureAtlasRegion_v2_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->v2, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_v2_get) + +static bool js_spine_TextureAtlasRegion_offsetX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offsetX, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_offsetX_set) + +static bool js_spine_TextureAtlasRegion_offsetX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offsetX, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_offsetX_get) + +static bool js_spine_TextureAtlasRegion_offsetY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->offsetY, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_offsetY_set) + +static bool js_spine_TextureAtlasRegion_offsetY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->offsetY, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_offsetY_get) + +static bool js_spine_TextureAtlasRegion_originalWidth_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->originalWidth, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_originalWidth_set) + +static bool js_spine_TextureAtlasRegion_originalWidth_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->originalWidth, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_originalWidth_get) + +static bool js_spine_TextureAtlasRegion_originalHeight_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->originalHeight, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_originalHeight_set) + +static bool js_spine_TextureAtlasRegion_originalHeight_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->originalHeight, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_originalHeight_get) + +static bool js_spine_TextureAtlasRegion_index_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->index, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_index_set) + +static bool js_spine_TextureAtlasRegion_index_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->index, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_index_get) + +static bool js_spine_TextureAtlasRegion_rotate_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->rotate); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_rotate_set) + +static bool js_spine_TextureAtlasRegion_rotate_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->rotate, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_rotate_get) + +static bool js_spine_TextureAtlasRegion_degrees_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->degrees, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_degrees_set) + +static bool js_spine_TextureAtlasRegion_degrees_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->degrees, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_degrees_get) + +static bool js_spine_TextureAtlasRegion_splits_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->splits, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_splits_set) + +static bool js_spine_TextureAtlasRegion_splits_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->splits, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->splits, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_splits_get) + +static bool js_spine_TextureAtlasRegion_pads_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->pads, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_spine_TextureAtlasRegion_pads_set) + +static bool js_spine_TextureAtlasRegion_pads_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::AtlasRegion *arg1 = (spine::AtlasRegion *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->pads, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->pads, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_spine_TextureAtlasRegion_pads_get) + +static bool js_new_spine_AtlasRegion(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + spine::AtlasRegion *result; + result = (spine::AtlasRegion *)new spine::AtlasRegion(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_AtlasRegion, __jsb_spine_AtlasRegion_class, js_delete_spine_AtlasRegion) + +static bool js_delete_spine_AtlasRegion(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_AtlasRegion) + +bool js_register_spine_AtlasRegion(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlasRegion", obj, nullptr, _SE(js_new_spine_AtlasRegion)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("page", _SE(js_spine_TextureAtlasRegion_page_get), _SE(js_spine_TextureAtlasRegion_page_set)); + cls->defineProperty("name", _SE(js_spine_TextureAtlasRegion_name_get), _SE(js_spine_TextureAtlasRegion_name_set)); + cls->defineProperty("x", _SE(js_spine_TextureAtlasRegion_x_get), _SE(js_spine_TextureAtlasRegion_x_set)); + cls->defineProperty("y", _SE(js_spine_TextureAtlasRegion_y_get), _SE(js_spine_TextureAtlasRegion_y_set)); + cls->defineProperty("width", _SE(js_spine_TextureAtlasRegion_width_get), _SE(js_spine_TextureAtlasRegion_width_set)); + cls->defineProperty("height", _SE(js_spine_TextureAtlasRegion_height_get), _SE(js_spine_TextureAtlasRegion_height_set)); + cls->defineProperty("u", _SE(js_spine_TextureAtlasRegion_u_get), _SE(js_spine_TextureAtlasRegion_u_set)); + cls->defineProperty("v", _SE(js_spine_TextureAtlasRegion_v_get), _SE(js_spine_TextureAtlasRegion_v_set)); + cls->defineProperty("u2", _SE(js_spine_TextureAtlasRegion_u2_get), _SE(js_spine_TextureAtlasRegion_u2_set)); + cls->defineProperty("v2", _SE(js_spine_TextureAtlasRegion_v2_get), _SE(js_spine_TextureAtlasRegion_v2_set)); + cls->defineProperty("offsetX", _SE(js_spine_TextureAtlasRegion_offsetX_get), _SE(js_spine_TextureAtlasRegion_offsetX_set)); + cls->defineProperty("offsetY", _SE(js_spine_TextureAtlasRegion_offsetY_get), _SE(js_spine_TextureAtlasRegion_offsetY_set)); + cls->defineProperty("originalWidth", _SE(js_spine_TextureAtlasRegion_originalWidth_get), _SE(js_spine_TextureAtlasRegion_originalWidth_set)); + cls->defineProperty("originalHeight", _SE(js_spine_TextureAtlasRegion_originalHeight_get), _SE(js_spine_TextureAtlasRegion_originalHeight_set)); + cls->defineProperty("index", _SE(js_spine_TextureAtlasRegion_index_get), _SE(js_spine_TextureAtlasRegion_index_set)); + cls->defineProperty("rotate", _SE(js_spine_TextureAtlasRegion_rotate_get), _SE(js_spine_TextureAtlasRegion_rotate_set)); + cls->defineProperty("degrees", _SE(js_spine_TextureAtlasRegion_degrees_get), _SE(js_spine_TextureAtlasRegion_degrees_set)); + cls->defineProperty("splits", _SE(js_spine_TextureAtlasRegion_splits_get), _SE(js_spine_TextureAtlasRegion_splits_set)); + cls->defineProperty("pads", _SE(js_spine_TextureAtlasRegion_pads_get), _SE(js_spine_TextureAtlasRegion_pads_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_AtlasRegion)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_AtlasRegion_proto = cls->getProto(); + __jsb_spine_AtlasRegion_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_Atlas_class = nullptr; +se::Object* __jsb_spine_Atlas_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_Atlas) + +static bool js_new_spine_Atlas__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::String *arg1 = 0 ; + spine::TextureLoader *arg2 = (spine::TextureLoader *) NULL ; + bool arg3 ; + spine::String temp1 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((spine::String const &)*arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::String *arg1 = 0 ; + spine::TextureLoader *arg2 = (spine::TextureLoader *) NULL ; + spine::String temp1 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((spine::String const &)*arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + char *arg1 = (char *) NULL ; + int arg2 ; + char *arg3 = (char *) NULL ; + spine::TextureLoader *arg4 = (spine::TextureLoader *) NULL ; + bool arg5 ; + ccstd::string temp1 ; + ccstd::string temp3 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = (char *) temp1.c_str(); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((char const *)arg1,arg2,(char const *)arg3,arg4,arg5); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + char *arg1 = (char *) NULL ; + int arg2 ; + char *arg3 = (char *) NULL ; + spine::TextureLoader *arg4 = (spine::TextureLoader *) NULL ; + ccstd::string temp1 ; + ccstd::string temp3 ; + spine::Atlas *result; + + ok &= sevalue_to_native(args[0], &temp1); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = (char *) temp1.c_str(); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &temp3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + + ok &= sevalue_to_native(args[3], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::Atlas *)new spine::Atlas((char const *)arg1,arg2,(char const *)arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_spine_Atlas(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 3) { + ret = js_new_spine_Atlas__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_spine_Atlas__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 5) { + ret = js_new_spine_Atlas__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_spine_Atlas__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of TextureAtlas"); + return false; +} +SE_BIND_CTOR(js_new_spine_Atlas, __jsb_spine_Atlas_class, js_delete_spine_Atlas) + +static bool js_delete_spine_Atlas(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_Atlas) + +static bool js_spine_TextureAtlas_flipV(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->flipV(); + + + return true; +} +SE_BIND_FUNC(js_spine_TextureAtlas_flipV) + +static bool js_spine_TextureAtlas_findRegion(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + spine::String *arg2 = 0 ; + spine::String temp2 ; + spine::AtlasRegion *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(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 = (spine::AtlasRegion *)(arg1)->findRegion((spine::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_spine_TextureAtlas_findRegion) + +static bool js_spine_TextureAtlas_getPages(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::Atlas *arg1 = (spine::Atlas *) NULL ; + spine::Vector< spine::AtlasPage * > *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(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::AtlasPage * > *) &(arg1)->getPages(); + + 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_spine_TextureAtlas_getPages) + +bool js_register_spine_Atlas(se::Object* obj) { + auto* cls = se::Class::create("TextureAtlas", obj, nullptr, _SE(js_new_spine_Atlas)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("flipV", _SE(js_spine_TextureAtlas_flipV)); + cls->defineFunction("findRegion", _SE(js_spine_TextureAtlas_findRegion)); + cls->defineFunction("getPages", _SE(js_spine_TextureAtlas_getPages)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_Atlas)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_Atlas_proto = cls->getProto(); + __jsb_spine_Atlas_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TextureLoader_class = nullptr; +se::Object* __jsb_spine_TextureLoader_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TextureLoader) + +static bool js_delete_spine_TextureLoader(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TextureLoader) + +static bool js_spine_TextureLoader_unload(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TextureLoader *arg1 = (spine::TextureLoader *) NULL ; + void *arg2 = (void *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->unload(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_TextureLoader_unload) + +static bool js_spine_TextureLoader_load(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TextureLoader *arg1 = (spine::TextureLoader *) NULL ; + spine::AtlasPage *arg2 = (spine::AtlasPage *) NULL ; + spine::String *arg3 = 0 ; + spine::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(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; + + spine_TextureLoader_load(arg1,arg2,(spine::String const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_spine_TextureLoader_load) + +bool js_register_spine_TextureLoader(se::Object* obj) { + auto* cls = se::Class::create("TextureLoader", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("unload", _SE(js_spine_TextureLoader_unload)); + cls->defineFunction("load", _SE(js_spine_TextureLoader_load)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TextureLoader)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TextureLoader_proto = cls->getProto(); + __jsb_spine_TextureLoader_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TransformConstraint_class = nullptr; +se::Object* __jsb_spine_TransformConstraint_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TransformConstraint) + +static bool js_spine_TransformConstraint_apply(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->apply(); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraint_apply) + +static bool js_spine_TransformConstraint_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->update(); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraint_update) + +static bool js_spine_TransformConstraint_getOrder(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + int result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (int)(arg1)->getOrder(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraint_getOrder) + +static bool js_spine_TransformConstraint_data_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::TransformConstraintData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TransformConstraintData *) &spine_TransformConstraint_data_get(arg1); + + ok &= nativevalue_to_se(*result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(*result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_data_get) + +static bool js_spine_TransformConstraint_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::Vector< spine::Bone * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::Bone * > *) &spine_TransformConstraint_bones_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_spine_TransformConstraint_bones_get) + +static bool js_spine_TransformConstraint_target_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::Bone *arg2 = (spine::Bone *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_target_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_target_set) + +static bool js_spine_TransformConstraint_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + spine::Bone *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Bone *)spine_TransformConstraint_target_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_spine_TransformConstraint_target_get) + +static bool js_spine_TransformConstraint_rotateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_rotateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_rotateMix_set) + +static bool js_spine_TransformConstraint_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_rotateMix_get) + +static bool js_spine_TransformConstraint_translateMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_translateMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_translateMix_set) + +static bool js_spine_TransformConstraint_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_translateMix_get) + +static bool js_spine_TransformConstraint_scaleMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_scaleMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_scaleMix_set) + +static bool js_spine_TransformConstraint_scaleMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_scaleMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_scaleMix_get) + +static bool js_spine_TransformConstraint_shearMix_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_shearMix_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_shearMix_set) + +static bool js_spine_TransformConstraint_shearMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraint_shearMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_shearMix_get) + +static bool js_spine_TransformConstraint_active_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + bool arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_TransformConstraint_active_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_TransformConstraint_active_set) + +static bool js_spine_TransformConstraint_active_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraint *arg1 = (spine::TransformConstraint *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TransformConstraint_active_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraint_active_get) + +static bool js_new_spine_TransformConstraint(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + spine::TransformConstraint *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TransformConstraint *)new_spine_TransformConstraint(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TransformConstraint, __jsb_spine_TransformConstraint_class, js_delete_spine_TransformConstraint) + +static bool js_delete_spine_TransformConstraint(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TransformConstraint) + +bool js_register_spine_TransformConstraint(se::Object* obj) { + auto* cls = se::Class::create("TransformConstraint", obj, nullptr, _SE(js_new_spine_TransformConstraint)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("data", _SE(js_spine_TransformConstraint_data_get), nullptr); + cls->defineProperty("bones", _SE(js_spine_TransformConstraint_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_TransformConstraint_target_get), _SE(js_spine_TransformConstraint_target_set)); + cls->defineProperty("rotateMix", _SE(js_spine_TransformConstraint_rotateMix_get), _SE(js_spine_TransformConstraint_rotateMix_set)); + cls->defineProperty("translateMix", _SE(js_spine_TransformConstraint_translateMix_get), _SE(js_spine_TransformConstraint_translateMix_set)); + cls->defineProperty("scaleMix", _SE(js_spine_TransformConstraint_scaleMix_get), _SE(js_spine_TransformConstraint_scaleMix_set)); + cls->defineProperty("shearMix", _SE(js_spine_TransformConstraint_shearMix_get), _SE(js_spine_TransformConstraint_shearMix_set)); + cls->defineProperty("active", _SE(js_spine_TransformConstraint_active_get), _SE(js_spine_TransformConstraint_active_set)); + + cls->defineFunction("apply", _SE(js_spine_TransformConstraint_apply)); + cls->defineFunction("update", _SE(js_spine_TransformConstraint_update)); + cls->defineFunction("getOrder", _SE(js_spine_TransformConstraint_getOrder)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TransformConstraint)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TransformConstraint_proto = cls->getProto(); + __jsb_spine_TransformConstraint_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TransformConstraintData_class = nullptr; +se::Object* __jsb_spine_TransformConstraintData_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TransformConstraintData) + +static bool js_new_spine_TransformConstraintData(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + spine::String *arg1 = 0 ; + spine::String temp1 ; + spine::TransformConstraintData *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + result = (spine::TransformConstraintData *)new spine::TransformConstraintData((spine::String const &)*arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TransformConstraintData, __jsb_spine_TransformConstraintData_class, js_delete_spine_TransformConstraintData) + +static bool js_spine_TransformConstraintData_bones_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + spine::Vector< spine::BoneData * > *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::Vector< spine::BoneData * > *) &spine_TransformConstraintData_bones_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_spine_TransformConstraintData_bones_get) + +static bool js_spine_TransformConstraintData_target_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + spine::BoneData *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::BoneData *)spine_TransformConstraintData_target_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_spine_TransformConstraintData_target_get) + +static bool js_spine_TransformConstraintData_rotateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_rotateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_rotateMix_get) + +static bool js_spine_TransformConstraintData_translateMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_translateMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_translateMix_get) + +static bool js_spine_TransformConstraintData_scaleMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_scaleMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_scaleMix_get) + +static bool js_spine_TransformConstraintData_shearMix_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_shearMix_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_shearMix_get) + +static bool js_spine_TransformConstraintData_offsetRotation_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetRotation_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetRotation_get) + +static bool js_spine_TransformConstraintData_offsetX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetX_get) + +static bool js_spine_TransformConstraintData_offsetY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetY_get) + +static bool js_spine_TransformConstraintData_offsetScaleX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetScaleX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetScaleX_get) + +static bool js_spine_TransformConstraintData_offsetScaleY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetScaleY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetScaleY_get) + +static bool js_spine_TransformConstraintData_offsetShearY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_TransformConstraintData_offsetShearY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_offsetShearY_get) + +static bool js_spine_TransformConstraintData_relative_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TransformConstraintData_relative_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_relative_get) + +static bool js_spine_TransformConstraintData_local_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::TransformConstraintData *arg1 = (spine::TransformConstraintData *) NULL ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (bool)spine_TransformConstraintData_local_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_TransformConstraintData_local_get) + +static bool js_delete_spine_TransformConstraintData(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TransformConstraintData) + +bool js_register_spine_TransformConstraintData(se::Object* obj) { + auto* cls = se::Class::create("TransformConstraintData", obj, __jsb_spine_ConstraintData_proto, _SE(js_new_spine_TransformConstraintData)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("bones", _SE(js_spine_TransformConstraintData_bones_get), nullptr); + cls->defineProperty("target", _SE(js_spine_TransformConstraintData_target_get), nullptr); + cls->defineProperty("rotateMix", _SE(js_spine_TransformConstraintData_rotateMix_get), nullptr); + cls->defineProperty("translateMix", _SE(js_spine_TransformConstraintData_translateMix_get), nullptr); + cls->defineProperty("scaleMix", _SE(js_spine_TransformConstraintData_scaleMix_get), nullptr); + cls->defineProperty("shearMix", _SE(js_spine_TransformConstraintData_shearMix_get), nullptr); + cls->defineProperty("offsetRotation", _SE(js_spine_TransformConstraintData_offsetRotation_get), nullptr); + cls->defineProperty("offsetX", _SE(js_spine_TransformConstraintData_offsetX_get), nullptr); + cls->defineProperty("offsetY", _SE(js_spine_TransformConstraintData_offsetY_get), nullptr); + cls->defineProperty("offsetScaleX", _SE(js_spine_TransformConstraintData_offsetScaleX_get), nullptr); + cls->defineProperty("offsetScaleY", _SE(js_spine_TransformConstraintData_offsetScaleY_get), nullptr); + cls->defineProperty("offsetShearY", _SE(js_spine_TransformConstraintData_offsetShearY_get), nullptr); + cls->defineProperty("relative", _SE(js_spine_TransformConstraintData_relative_get), nullptr); + cls->defineProperty("local", _SE(js_spine_TransformConstraintData_local_get), nullptr); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TransformConstraintData)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TransformConstraintData_proto = cls->getProto(); + __jsb_spine_TransformConstraintData_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_TransformConstraintTimeline_class = nullptr; +se::Object* __jsb_spine_TransformConstraintTimeline_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_TransformConstraintTimeline) + +static bool js_new_spine_TransformConstraintTimeline(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + + int arg1 ; + spine::TransformConstraintTimeline *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TransformConstraintTimeline *)new spine::TransformConstraintTimeline(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_TransformConstraintTimeline, __jsb_spine_TransformConstraintTimeline_class, js_delete_spine_TransformConstraintTimeline) + +static bool js_spine_TransformConstraintTimeline_setFrame(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::TransformConstraintTimeline *arg1 = (spine::TransformConstraintTimeline *) NULL ; + size_t arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + + if(argc != 6) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 6); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[4], &arg6, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[5], &arg7, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setFrame(arg2,arg3,arg4,arg5,arg6,arg7); + + + return true; +} +SE_BIND_FUNC(js_spine_TransformConstraintTimeline_setFrame) + +static bool js_delete_spine_TransformConstraintTimeline(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_TransformConstraintTimeline) + +bool js_register_spine_TransformConstraintTimeline(se::Object* obj) { + auto* cls = se::Class::create("TransformConstraintTimeline", obj, __jsb_spine_CurveTimeline_proto, _SE(js_new_spine_TransformConstraintTimeline)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setFrame", _SE(js_spine_TransformConstraintTimeline_setFrame)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_TransformConstraintTimeline)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_TransformConstraintTimeline_proto = cls->getProto(); + __jsb_spine_TransformConstraintTimeline_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_VertexEffect_class = nullptr; +se::Object* __jsb_spine_VertexEffect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_VertexEffect) + +static bool js_spine_VertexEffect_end(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexEffect *arg1 = (spine::VertexEffect *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->end(); + + + return true; +} +SE_BIND_FUNC(js_spine_VertexEffect_end) + +static bool js_spine_VertexEffect_begin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::VertexEffect *arg1 = (spine::VertexEffect *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_VertexEffect_begin(arg1,arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_VertexEffect_begin) + +static bool js_delete_spine_VertexEffect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_VertexEffect) + +bool js_register_spine_VertexEffect(se::Object* obj) { + auto* cls = se::Class::create("VertexEffect", obj, nullptr, nullptr); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("end", _SE(js_spine_VertexEffect_end)); + cls->defineFunction("begin", _SE(js_spine_VertexEffect_begin)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_VertexEffect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_VertexEffect_proto = cls->getProto(); + __jsb_spine_VertexEffect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_JitterVertexEffect_class = nullptr; +se::Object* __jsb_spine_JitterVertexEffect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_JitterVertexEffect) + +static bool js_new_spine_JitterVertexEffect(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + float arg2 ; + spine::JitterVertexEffect *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::JitterVertexEffect *)new spine::JitterVertexEffect(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_JitterVertexEffect, __jsb_spine_JitterVertexEffect_class, js_delete_spine_JitterVertexEffect) + +static bool js_spine_JitterEffect_jitterX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_JitterVertexEffect_jitterX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_JitterEffect_jitterX_set) + +static bool js_spine_JitterEffect_jitterX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_JitterVertexEffect_jitterX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_JitterEffect_jitterX_get) + +static bool js_spine_JitterEffect_jitterY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_JitterVertexEffect_jitterY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_JitterEffect_jitterY_set) + +static bool js_spine_JitterEffect_jitterY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::JitterVertexEffect *arg1 = (spine::JitterVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_JitterVertexEffect_jitterY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_JitterEffect_jitterY_get) + +static bool js_delete_spine_JitterVertexEffect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_JitterVertexEffect) + +bool js_register_spine_JitterVertexEffect(se::Object* obj) { + auto* cls = se::Class::create("JitterEffect", obj, __jsb_spine_VertexEffect_proto, _SE(js_new_spine_JitterVertexEffect)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("jitterX", _SE(js_spine_JitterEffect_jitterX_get), _SE(js_spine_JitterEffect_jitterX_set)); + cls->defineProperty("jitterY", _SE(js_spine_JitterEffect_jitterY_get), _SE(js_spine_JitterEffect_jitterY_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_JitterVertexEffect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_JitterVertexEffect_proto = cls->getProto(); + __jsb_spine_JitterVertexEffect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_spine_SwirlVertexEffect_class = nullptr; +se::Object* __jsb_spine_SwirlVertexEffect_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_spine_SwirlVertexEffect) + +static bool js_spine_SwirlEffect_setWorldX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setWorldX(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_setWorldX) + +static bool js_spine_SwirlEffect_getWorldX(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldX(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_getWorldX) + +static bool js_spine_SwirlEffect_setWorldY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setWorldY(arg2); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_setWorldY) + +static bool js_spine_SwirlEffect_getWorldY(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)(arg1)->getWorldY(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_spine_SwirlEffect_getWorldY) + +static bool js_spine_SwirlEffect_centerX_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_centerX_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_centerX_set) + +static bool js_spine_SwirlEffect_centerX_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_centerX_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_centerX_get) + +static bool js_spine_SwirlEffect_centerY_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_centerY_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_centerY_set) + +static bool js_spine_SwirlEffect_centerY_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_centerY_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_centerY_get) + +static bool js_spine_SwirlEffect_radius_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_radius_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_radius_set) + +static bool js_spine_SwirlEffect_radius_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_radius_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_radius_get) + +static bool js_spine_SwirlEffect_angle_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + spine_SwirlVertexEffect_angle_set(arg1,arg2); + + + return true; +} +SE_BIND_PROP_SET(js_spine_SwirlEffect_angle_set) + +static bool js_spine_SwirlEffect_angle_get(se::State& s) +{ + CC_UNUSED bool ok = true; + spine::SwirlVertexEffect *arg1 = (spine::SwirlVertexEffect *) NULL ; + float result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)spine_SwirlVertexEffect_angle_get(arg1); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_PROP_GET(js_spine_SwirlEffect_angle_get) + +static bool js_new_spine_SwirlVertexEffect(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + float arg1 ; + spine::Interpolation *arg2 = (spine::Interpolation *) NULL ; + spine::SwirlVertexEffect *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::SwirlVertexEffect *)new_spine_SwirlVertexEffect(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_spine_SwirlVertexEffect, __jsb_spine_SwirlVertexEffect_class, js_delete_spine_SwirlVertexEffect) + +static bool js_delete_spine_SwirlVertexEffect(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_spine_SwirlVertexEffect) + +bool js_register_spine_SwirlVertexEffect(se::Object* obj) { + auto* cls = se::Class::create("SwirlEffect", obj, __jsb_spine_VertexEffect_proto, _SE(js_new_spine_SwirlVertexEffect)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("centerX", _SE(js_spine_SwirlEffect_centerX_get), _SE(js_spine_SwirlEffect_centerX_set)); + cls->defineProperty("centerY", _SE(js_spine_SwirlEffect_centerY_get), _SE(js_spine_SwirlEffect_centerY_set)); + cls->defineProperty("radius", _SE(js_spine_SwirlEffect_radius_get), _SE(js_spine_SwirlEffect_radius_set)); + cls->defineProperty("angle", _SE(js_spine_SwirlEffect_angle_get), _SE(js_spine_SwirlEffect_angle_set)); + + cls->defineFunction("setWorldX", _SE(js_spine_SwirlEffect_setWorldX)); + cls->defineFunction("getWorldX", _SE(js_spine_SwirlEffect_getWorldX)); + cls->defineFunction("setWorldY", _SE(js_spine_SwirlEffect_setWorldY)); + cls->defineFunction("getWorldY", _SE(js_spine_SwirlEffect_getWorldY)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_spine_SwirlVertexEffect)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_spine_SwirlVertexEffect_proto = cls->getProto(); + __jsb_spine_SwirlVertexEffect_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_VertexEffectDelegate_class = nullptr; +se::Object* __jsb_cc_VertexEffectDelegate_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_VertexEffectDelegate) + +static bool js_new_cc_VertexEffectDelegate(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::VertexEffectDelegate *result; + result = (cc::VertexEffectDelegate *)new cc::VertexEffectDelegate(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_VertexEffectDelegate, __jsb_cc_VertexEffectDelegate_class, js_delete_cc_VertexEffectDelegate) + +static bool js_delete_cc_VertexEffectDelegate(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_VertexEffectDelegate) + +static bool js_cc_VertexEffectDelegate_initJitter(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + float arg2 ; + float arg3 ; + spine::JitterVertexEffect *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(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 = (spine::JitterVertexEffect *)(arg1)->initJitter(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_VertexEffectDelegate_initJitter) + +static bool js_cc_VertexEffectDelegate_initSwirlWithPow(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + float arg2 ; + int arg3 ; + spine::SwirlVertexEffect *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(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 = (spine::SwirlVertexEffect *)(arg1)->initSwirlWithPow(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_VertexEffectDelegate_initSwirlWithPow) + +static bool js_cc_VertexEffectDelegate_initSwirlWithPowOut(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + float arg2 ; + int arg3 ; + spine::SwirlVertexEffect *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(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 = (spine::SwirlVertexEffect *)(arg1)->initSwirlWithPowOut(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_VertexEffectDelegate_initSwirlWithPowOut) + +static bool js_cc_VertexEffectDelegate_getVertexEffect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + spine::VertexEffect *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(s); + if (nullptr == arg1) return true; + result = (spine::VertexEffect *)(arg1)->getVertexEffect(); + + 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_VertexEffectDelegate_getVertexEffect) + +static bool js_cc_VertexEffectDelegate_getJitterVertexEffect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + spine::JitterVertexEffect *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(s); + if (nullptr == arg1) return true; + result = (spine::JitterVertexEffect *)(arg1)->getJitterVertexEffect(); + + 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_VertexEffectDelegate_getJitterVertexEffect) + +static bool js_cc_VertexEffectDelegate_getSwirlVertexEffect(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + spine::SwirlVertexEffect *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(s); + if (nullptr == arg1) return true; + result = (spine::SwirlVertexEffect *)(arg1)->getSwirlVertexEffect(); + + 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_VertexEffectDelegate_getSwirlVertexEffect) + +static bool js_cc_VertexEffectDelegate_getEffectType(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + std::string *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(s); + if (nullptr == arg1) return true; + result = (std::string *) &((cc::VertexEffectDelegate const *)arg1)->getEffectType(); + + 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_VertexEffectDelegate_getEffectType) + +static bool js_cc_VertexEffectDelegate_clear(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::VertexEffectDelegate *arg1 = (cc::VertexEffectDelegate *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clear(); + + + return true; +} +SE_BIND_FUNC(js_cc_VertexEffectDelegate_clear) + +bool js_register_cc_VertexEffectDelegate(se::Object* obj) { + auto* cls = se::Class::create("VertexEffectDelegate", obj, nullptr, _SE(js_new_cc_VertexEffectDelegate)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("initJitter", _SE(js_cc_VertexEffectDelegate_initJitter)); + cls->defineFunction("initSwirlWithPow", _SE(js_cc_VertexEffectDelegate_initSwirlWithPow)); + cls->defineFunction("initSwirlWithPowOut", _SE(js_cc_VertexEffectDelegate_initSwirlWithPowOut)); + cls->defineFunction("getVertexEffect", _SE(js_cc_VertexEffectDelegate_getVertexEffect)); + cls->defineFunction("getJitterVertexEffect", _SE(js_cc_VertexEffectDelegate_getJitterVertexEffect)); + cls->defineFunction("getSwirlVertexEffect", _SE(js_cc_VertexEffectDelegate_getSwirlVertexEffect)); + cls->defineFunction("getEffectType", _SE(js_cc_VertexEffectDelegate_getEffectType)); + cls->defineFunction("clear", _SE(js_cc_VertexEffectDelegate_clear)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_VertexEffectDelegate)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_VertexEffectDelegate_proto = cls->getProto(); + __jsb_cc_VertexEffectDelegate_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonRenderer_class = nullptr; +se::Object* __jsb_cc_SkeletonRenderer_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonRenderer) + +static bool js_cc_SkeletonRenderer_create_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)cc::SkeletonRenderer::createWithFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonRenderer_create_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonRenderer *)cc::SkeletonRenderer::createWithFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonRenderer_create_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonRenderer_create_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonRenderer_create_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_create_static) + +static bool js_cc_SkeletonRenderer_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_update) + +static bool js_cc_SkeletonRenderer_render(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->render(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_render) + +static bool js_cc_SkeletonRenderer_getBoundingBox(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::Rect result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonRenderer const *)arg1)->getBoundingBox(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getBoundingBox) + +static bool js_cc_SkeletonRenderer_getSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *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(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *)((cc::SkeletonRenderer const *)arg1)->getSkeleton(); + + 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_SkeletonRenderer_getSkeleton) + +static bool js_cc_SkeletonRenderer_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setTimeScale) + +static bool js_cc_SkeletonRenderer_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::SkeletonRenderer const *)arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getTimeScale) + +static bool js_cc_SkeletonRenderer_updateWorldTransform(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateWorldTransform(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_updateWorldTransform) + +static bool js_cc_SkeletonRenderer_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setToSetupPose) + +static bool js_cc_SkeletonRenderer_setBonesToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setBonesToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setBonesToSetupPose) + +static bool js_cc_SkeletonRenderer_setSlotsToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setSlotsToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSlotsToSetupPose) + +static bool js_cc_SkeletonRenderer_paused(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->paused(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_paused) + +static bool js_cc_SkeletonRenderer_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Bone *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(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 = (spine::Bone *)((cc::SkeletonRenderer const *)arg1)->findBone((std::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_SkeletonRenderer_findBone) + +static bool js_cc_SkeletonRenderer_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Slot *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(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 = (spine::Slot *)((cc::SkeletonRenderer const *)arg1)->findSlot((std::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_SkeletonRenderer_findSlot) + +static bool js_cc_SkeletonRenderer_setSkin__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setSkin((std::string const &)*arg2); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setSkin__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + char *arg2 = (char *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + (arg1)->setSkin((char const *)arg2); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonRenderer_setSkin__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SkeletonRenderer_setSkin__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSkin) + +static bool js_cc_SkeletonRenderer_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *)((cc::SkeletonRenderer const *)arg1)->getAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getAttachment) + +static bool js_cc_SkeletonRenderer_setAttachment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setAttachment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + char *arg3 = (char *) NULL ; + std::string temp2 ; + ccstd::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(char const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonRenderer_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_SkeletonRenderer_setAttachment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonRenderer_setAttachment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setAttachment) + +static bool js_cc_SkeletonRenderer_setUseTint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUseTint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setUseTint) + +static bool js_cc_SkeletonRenderer_setVertexEffectDelegate(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::VertexEffectDelegate *arg2 = (cc::VertexEffectDelegate *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setVertexEffectDelegate(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setVertexEffectDelegate) + +static bool js_cc_SkeletonRenderer_setSlotsRange(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + int arg2 ; + int arg3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setSlotsRange(arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSlotsRange) + +static bool js_cc_SkeletonRenderer_getDebugData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonRenderer const *)arg1)->getDebugData(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getDebugData) + +static bool js_cc_SkeletonRenderer_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonRenderer const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_getSharedBufferOffset) + +static bool js_cc_SkeletonRenderer_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setColor) + +static bool js_cc_SkeletonRenderer_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setBatchEnabled) + +static bool js_cc_SkeletonRenderer_setDebugBonesEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugBonesEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setDebugBonesEnabled) + +static bool js_cc_SkeletonRenderer_setDebugSlotsEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugSlotsEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setDebugSlotsEnabled) + +static bool js_cc_SkeletonRenderer_setDebugMeshEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setDebugMeshEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setDebugMeshEnabled) + +static bool js_cc_SkeletonRenderer_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setAttachEnabled) + +static bool js_cc_SkeletonRenderer_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setOpacityModifyRGB) + +static bool js_cc_SkeletonRenderer_isOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::SkeletonRenderer const *)arg1)->isOpacityModifyRGB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_isOpacityModifyRGB) + +static bool js_cc_SkeletonRenderer_beginSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_beginSchedule) + +static bool js_cc_SkeletonRenderer_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_stopSchedule) + +static bool js_cc_SkeletonRenderer_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_onEnable) + +static bool js_cc_SkeletonRenderer_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_onDisable) + +static bool js_new_cc_SkeletonRenderer__SWIG_0(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + cc::SkeletonRenderer *result; + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_1(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2,arg3,arg4); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_2(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + bool arg2 ; + bool arg3 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg3); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_3(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + bool arg2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_4(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::Skeleton *arg1 = (spine::Skeleton *) NULL ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_5(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + bool arg2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_6(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + spine::SkeletonData *arg1 = (spine::SkeletonData *) NULL ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &arg1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer(arg1); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_7(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer((std::string const &)*arg1,(std::string const &)*arg2,arg3); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer__SWIG_8(se::State& s) // NOLINT(readability-identifier-naming) +{ + const auto& args = s.args(); + CC_UNUSED bool ok = true; + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonRenderer *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonRenderer *)new cc::SkeletonRenderer((std::string const &)*arg1,(std::string const &)*arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} + + +static bool js_new_cc_SkeletonRenderer(se::State& s) // NOLINT(readability-identifier-naming) +{ + size_t argc = s.args().size(); + bool ret = false; + + if(argc == 0) { + ret = js_new_cc_SkeletonRenderer__SWIG_0(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 4) { + ret = js_new_cc_SkeletonRenderer__SWIG_1(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_SkeletonRenderer__SWIG_2(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_SkeletonRenderer__SWIG_3(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_SkeletonRenderer__SWIG_4(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_SkeletonRenderer__SWIG_5(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 1) { + ret = js_new_cc_SkeletonRenderer__SWIG_6(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 3) { + ret = js_new_cc_SkeletonRenderer__SWIG_7(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + if(argc == 2) { + ret = js_new_cc_SkeletonRenderer__SWIG_8(s); + if (ret) { + return ret; + } /* reset exception and return */ + } + + SE_REPORT_ERROR("Illegal arguments for construction of SkeletonRenderer"); + return false; +} +SE_BIND_CTOR(js_new_cc_SkeletonRenderer, __jsb_cc_SkeletonRenderer_class, js_delete_cc_SkeletonRenderer) + +static bool js_delete_cc_SkeletonRenderer(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonRenderer) + +static bool js_cc_SkeletonRenderer_initWithUUID(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->initWithUUID((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_initWithUUID) + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + bool arg4 ; + bool arg5 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2,arg3,arg4,arg5); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + bool arg4 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_2(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + bool arg3 ; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2,arg3); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton__SWIG_3(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + spine::Skeleton *arg2 = (spine::Skeleton *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->initWithSkeleton(arg2); + + + return true; +} + +static bool js_cc_SkeletonRenderer_initWithSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_1(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_2(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SkeletonRenderer_initWithSkeleton__SWIG_3(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_initWithSkeleton) + +static bool js_cc_SkeletonRenderer_initialize(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->initialize(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_initialize) + +static bool js_cc_SkeletonRenderer_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setMaterial) + +static bool js_cc_SkeletonRenderer_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setRenderEntity) + +static bool js_cc_SkeletonRenderer_setSlotTexture(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonRenderer *arg1 = (cc::SkeletonRenderer *) NULL ; + std::string *arg2 = 0 ; + cc::Texture2D *arg3 = (cc::Texture2D *) NULL ; + bool arg4 ; + std::string temp2 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setSlotTexture((std::string const &)*arg2,arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonRenderer_setSlotTexture) + +bool js_register_cc_SkeletonRenderer(se::Object* obj) { + auto* cls = se::Class::create("SkeletonRenderer", obj, nullptr, _SE(js_new_cc_SkeletonRenderer)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_SkeletonRenderer_update)); + cls->defineFunction("render", _SE(js_cc_SkeletonRenderer_render)); + cls->defineFunction("getBoundingBox", _SE(js_cc_SkeletonRenderer_getBoundingBox)); + cls->defineFunction("getSkeleton", _SE(js_cc_SkeletonRenderer_getSkeleton)); + cls->defineFunction("setTimeScale", _SE(js_cc_SkeletonRenderer_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_cc_SkeletonRenderer_getTimeScale)); + cls->defineFunction("updateWorldTransform", _SE(js_cc_SkeletonRenderer_updateWorldTransform)); + cls->defineFunction("setToSetupPose", _SE(js_cc_SkeletonRenderer_setToSetupPose)); + cls->defineFunction("setBonesToSetupPose", _SE(js_cc_SkeletonRenderer_setBonesToSetupPose)); + cls->defineFunction("setSlotsToSetupPose", _SE(js_cc_SkeletonRenderer_setSlotsToSetupPose)); + cls->defineFunction("paused", _SE(js_cc_SkeletonRenderer_paused)); + cls->defineFunction("findBone", _SE(js_cc_SkeletonRenderer_findBone)); + cls->defineFunction("findSlot", _SE(js_cc_SkeletonRenderer_findSlot)); + cls->defineFunction("setSkin", _SE(js_cc_SkeletonRenderer_setSkin)); + cls->defineFunction("getAttachment", _SE(js_cc_SkeletonRenderer_getAttachment)); + cls->defineFunction("setAttachment", _SE(js_cc_SkeletonRenderer_setAttachment)); + cls->defineFunction("setUseTint", _SE(js_cc_SkeletonRenderer_setUseTint)); + cls->defineFunction("setVertexEffectDelegate", _SE(js_cc_SkeletonRenderer_setVertexEffectDelegate)); + cls->defineFunction("setSlotsRange", _SE(js_cc_SkeletonRenderer_setSlotsRange)); + cls->defineFunction("getDebugData", _SE(js_cc_SkeletonRenderer_getDebugData)); + cls->defineFunction("getSharedBufferOffset", _SE(js_cc_SkeletonRenderer_getSharedBufferOffset)); + cls->defineFunction("setColor", _SE(js_cc_SkeletonRenderer_setColor)); + cls->defineFunction("setBatchEnabled", _SE(js_cc_SkeletonRenderer_setBatchEnabled)); + cls->defineFunction("setDebugBonesEnabled", _SE(js_cc_SkeletonRenderer_setDebugBonesEnabled)); + cls->defineFunction("setDebugSlotsEnabled", _SE(js_cc_SkeletonRenderer_setDebugSlotsEnabled)); + cls->defineFunction("setDebugMeshEnabled", _SE(js_cc_SkeletonRenderer_setDebugMeshEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_cc_SkeletonRenderer_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_cc_SkeletonRenderer_setOpacityModifyRGB)); + cls->defineFunction("isOpacityModifyRGB", _SE(js_cc_SkeletonRenderer_isOpacityModifyRGB)); + cls->defineFunction("beginSchedule", _SE(js_cc_SkeletonRenderer_beginSchedule)); + cls->defineFunction("stopSchedule", _SE(js_cc_SkeletonRenderer_stopSchedule)); + cls->defineFunction("onEnable", _SE(js_cc_SkeletonRenderer_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_SkeletonRenderer_onDisable)); + cls->defineFunction("initWithUUID", _SE(js_cc_SkeletonRenderer_initWithUUID)); + cls->defineFunction("initWithSkeleton", _SE(js_cc_SkeletonRenderer_initWithSkeleton)); + cls->defineFunction("initialize", _SE(js_cc_SkeletonRenderer_initialize)); + cls->defineFunction("setMaterial", _SE(js_cc_SkeletonRenderer_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_cc_SkeletonRenderer_setRenderEntity)); + cls->defineFunction("setSlotTexture", _SE(js_cc_SkeletonRenderer_setSlotTexture)); + + + cls->defineStaticFunction("create", _SE(js_cc_SkeletonRenderer_create_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonRenderer)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonRenderer_proto = cls->getProto(); + __jsb_cc_SkeletonRenderer_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_CacheEventInfo_class = nullptr; +se::Object* __jsb_cc_CacheEventInfo_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_CacheEventInfo) + +static bool js_cc_CacheEventInfo_type_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->type, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + + return true; +} +SE_BIND_PROP_SET(js_cc_CacheEventInfo_type_set) + +static bool js_cc_CacheEventInfo_type_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->type, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->type, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_PROP_GET(js_cc_CacheEventInfo_type_get) + +static bool js_cc_CacheEventInfo_entry_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->entry, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CacheEventInfo_entry_set) + +static bool js_cc_CacheEventInfo_entry_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->entry, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->entry, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CacheEventInfo_entry_get) + +static bool js_cc_CacheEventInfo_event_set(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg1->event, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + + return true; +} +SE_BIND_PROP_SET(js_cc_CacheEventInfo_event_set) + +static bool js_cc_CacheEventInfo_event_get(se::State& s) +{ + CC_UNUSED bool ok = true; + cc::CacheEventInfo *arg1 = (cc::CacheEventInfo *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= nativevalue_to_se(arg1->event, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(arg1->event, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_PROP_GET(js_cc_CacheEventInfo_event_get) + +static bool js_new_cc_CacheEventInfo(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::CacheEventInfo *result; + result = (cc::CacheEventInfo *)new cc::CacheEventInfo(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_CacheEventInfo, __jsb_cc_CacheEventInfo_class, js_delete_cc_CacheEventInfo) + +static bool js_delete_cc_CacheEventInfo(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_CacheEventInfo) + +template<> +bool sevalue_to_native(const se::Value &from, cc::CacheEventInfo * to, se::Object *ctx) +{ + assert(from.isObject()); + se::Object *json = from.toObject(); + auto* data = reinterpret_cast(json->getPrivateData()); + if (data) { + *to = *data; + return true; + } + se::Value field; + bool ok = true; + + json->getProperty("type", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->type), ctx); + } + + + json->getProperty("entry", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->entry), ctx); + } + + + json->getProperty("event", &field, true); + if (!field.isNullOrUndefined()) { + ok &= sevalue_to_native(field, &(to->event), ctx); + } + + + return ok; +} + + +bool js_register_cc_CacheEventInfo(se::Object* obj) { + auto* cls = se::Class::create("CacheEventInfo", obj, nullptr, _SE(js_new_cc_CacheEventInfo)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + cls->defineProperty("type", _SE(js_cc_CacheEventInfo_type_get), _SE(js_cc_CacheEventInfo_type_set)); + cls->defineProperty("entry", _SE(js_cc_CacheEventInfo_entry_get), _SE(js_cc_CacheEventInfo_entry_set)); + cls->defineProperty("event", _SE(js_cc_CacheEventInfo_event_get), _SE(js_cc_CacheEventInfo_event_set)); + + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_CacheEventInfo)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_CacheEventInfo_proto = cls->getProto(); + __jsb_cc_CacheEventInfo_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonAnimation_class = nullptr; +se::Object* __jsb_cc_SkeletonAnimation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonAnimation) + +static bool js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithJsonFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithJsonFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithJsonFile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonAnimation_createWithJsonFile_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_createWithJsonFile_static) + +static bool js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + float arg3 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[2], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithBinaryFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + std::string *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string temp1 ; + std::string temp2 ; + cc::SkeletonAnimation *result = 0 ; + + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + result = (cc::SkeletonAnimation *)cc::SkeletonAnimation::createWithBinaryFile((std::string const &)*arg1,(std::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; +} + +static bool js_cc_SkeletonAnimation_createWithBinaryFile_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonAnimation_createWithBinaryFile_static__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_createWithBinaryFile_static) + +static bool js_cc_SkeletonAnimation_setGlobalTimeScale_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + float arg1 ; + + 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::SkeletonAnimation::setGlobalTimeScale(arg1); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setGlobalTimeScale_static) + +static bool js_cc_SkeletonAnimation_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_update) + +static bool js_cc_SkeletonAnimation_setAnimationStateData(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::AnimationStateData *arg2 = (spine::AnimationStateData *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAnimationStateData(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setAnimationStateData) + +static bool js_cc_SkeletonAnimation_setMix(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + float arg4 ; + std::string temp2 ; + std::string temp3 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMix((std::string const &)*arg2,(std::string const &)*arg3,arg4); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setMix) + +static bool js_cc_SkeletonAnimation_setAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + std::string *arg3 = 0 ; + bool arg4 ; + std::string temp3 ; + spine::TrackEntry *result = 0 ; + + if(argc != 3) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->setAnimation(arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setAnimation) + +static bool js_cc_SkeletonAnimation_addAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + std::string *arg3 = 0 ; + bool arg4 ; + float arg5 ; + std::string temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[3], &arg5, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,(std::string const &)*arg3,arg4,arg5); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_SkeletonAnimation_addAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + std::string *arg3 = 0 ; + bool arg4 ; + std::string temp3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + + ok &= sevalue_to_native(args[2], &arg4); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addAnimation(arg2,(std::string const &)*arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_SkeletonAnimation_addAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 4) { + ok = js_cc_SkeletonAnimation_addAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 3) { + ok = js_cc_SkeletonAnimation_addAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_addAnimation) + +static bool js_cc_SkeletonAnimation_setEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + float arg3 ; + spine::TrackEntry *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(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 = (spine::TrackEntry *)(arg1)->setEmptyAnimation(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_SkeletonAnimation_setEmptyAnimation) + +static bool js_cc_SkeletonAnimation_setEmptyAnimations(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setEmptyAnimations(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setEmptyAnimations) + +static bool js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + float arg3 ; + float arg4 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &arg3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->addEmptyAnimation(arg2,arg3,arg4); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} + +static bool js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + float arg3 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(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 = (spine::TrackEntry *)(arg1)->addEmptyAnimation(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_SkeletonAnimation_addEmptyAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonAnimation_addEmptyAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_addEmptyAnimation) + +static bool js_cc_SkeletonAnimation_findAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Animation *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(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 = (spine::Animation *)((cc::SkeletonAnimation const *)arg1)->findAnimation((std::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_SkeletonAnimation_findAnimation) + +static bool js_cc_SkeletonAnimation_getCurrent__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (spine::TrackEntry *)(arg1)->getCurrent(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_SkeletonAnimation_getCurrent__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *result = 0 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (spine::TrackEntry *)(arg1)->getCurrent(); + + 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_SkeletonAnimation_getCurrent(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonAnimation_getCurrent__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_SkeletonAnimation_getCurrent__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_getCurrent) + +static bool js_cc_SkeletonAnimation_clearTracks(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearTracks(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_clearTracks) + +static bool js_cc_SkeletonAnimation_clearTrack__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + int arg2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->clearTrack(arg2); + + + return true; +} + +static bool js_cc_SkeletonAnimation_clearTrack__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->clearTrack(); + + + return true; +} + +static bool js_cc_SkeletonAnimation_clearTrack(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonAnimation_clearTrack__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 0) { + ok = js_cc_SkeletonAnimation_clearTrack__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_clearTrack) + +static bool js_cc_SkeletonAnimation_setStartListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::StartListener *arg2 = 0 ; + cc::StartListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStartListener((cc::StartListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setStartListener) + +static bool js_cc_SkeletonAnimation_setInterruptListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::InterruptListener *arg2 = 0 ; + cc::InterruptListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setInterruptListener((cc::InterruptListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setInterruptListener) + +static bool js_cc_SkeletonAnimation_setEndListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::EndListener *arg2 = 0 ; + cc::EndListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEndListener((cc::EndListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setEndListener) + +static bool js_cc_SkeletonAnimation_setDisposeListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::DisposeListener *arg2 = 0 ; + cc::DisposeListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setDisposeListener((cc::DisposeListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setDisposeListener) + +static bool js_cc_SkeletonAnimation_setCompleteListenerNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::CompleteListener *arg2 = 0 ; + cc::CompleteListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCompleteListener((cc::CompleteListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setCompleteListenerNative) + +static bool js_cc_SkeletonAnimation_setEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + cc::EventListener *arg2 = 0 ; + cc::EventListener temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEventListener((cc::EventListener const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setEventListener) + +static bool js_cc_SkeletonAnimation_setTrackStartListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::StartListener *arg3 = 0 ; + cc::StartListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackStartListener(arg2,(cc::StartListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackStartListener) + +static bool js_cc_SkeletonAnimation_setTrackInterruptListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::InterruptListener *arg3 = 0 ; + cc::InterruptListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackInterruptListener(arg2,(cc::InterruptListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackInterruptListener) + +static bool js_cc_SkeletonAnimation_setTrackEndListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::EndListener *arg3 = 0 ; + cc::EndListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackEndListener(arg2,(cc::EndListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackEndListener) + +static bool js_cc_SkeletonAnimation_setTrackDisposeListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::DisposeListener *arg3 = 0 ; + cc::DisposeListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackDisposeListener(arg2,(cc::DisposeListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackDisposeListener) + +static bool js_cc_SkeletonAnimation_setTrackCompleteListenerNative(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::CompleteListener *arg3 = 0 ; + cc::CompleteListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackCompleteListener(arg2,(cc::CompleteListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackCompleteListenerNative) + +static bool js_cc_SkeletonAnimation_setTrackEventListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::TrackEntry *arg2 = (spine::TrackEntry *) NULL ; + cc::EventListener *arg3 = 0 ; + cc::EventListener temp3 ; + + if(argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + (arg1)->setTrackEventListener(arg2,(cc::EventListener const &)*arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonAnimation_setTrackEventListener) + +static bool js_cc_SkeletonAnimation_getState(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonAnimation *arg1 = (cc::SkeletonAnimation *) NULL ; + spine::AnimationState *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(s); + if (nullptr == arg1) return true; + result = (spine::AnimationState *)((cc::SkeletonAnimation const *)arg1)->getState(); + + 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_SkeletonAnimation_getState) + +static bool js_new_cc_SkeletonAnimation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkeletonAnimation *result; + result = (cc::SkeletonAnimation *)new cc::SkeletonAnimation(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonAnimation, __jsb_cc_SkeletonAnimation_class, js_delete_cc_SkeletonAnimation) + +static bool js_delete_cc_SkeletonAnimation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonAnimation) + +bool js_register_cc_SkeletonAnimation(se::Object* obj) { + auto* cls = se::Class::create("SkeletonAnimation", obj, __jsb_cc_SkeletonRenderer_proto, _SE(js_new_cc_SkeletonAnimation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_SkeletonAnimation_update)); + cls->defineFunction("setAnimationStateData", _SE(js_cc_SkeletonAnimation_setAnimationStateData)); + cls->defineFunction("setMix", _SE(js_cc_SkeletonAnimation_setMix)); + cls->defineFunction("setAnimation", _SE(js_cc_SkeletonAnimation_setAnimation)); + cls->defineFunction("addAnimation", _SE(js_cc_SkeletonAnimation_addAnimation)); + cls->defineFunction("setEmptyAnimation", _SE(js_cc_SkeletonAnimation_setEmptyAnimation)); + cls->defineFunction("setEmptyAnimations", _SE(js_cc_SkeletonAnimation_setEmptyAnimations)); + cls->defineFunction("addEmptyAnimation", _SE(js_cc_SkeletonAnimation_addEmptyAnimation)); + cls->defineFunction("findAnimation", _SE(js_cc_SkeletonAnimation_findAnimation)); + cls->defineFunction("getCurrent", _SE(js_cc_SkeletonAnimation_getCurrent)); + cls->defineFunction("clearTracks", _SE(js_cc_SkeletonAnimation_clearTracks)); + cls->defineFunction("clearTrack", _SE(js_cc_SkeletonAnimation_clearTrack)); + cls->defineFunction("setStartListener", _SE(js_cc_SkeletonAnimation_setStartListener)); + cls->defineFunction("setInterruptListener", _SE(js_cc_SkeletonAnimation_setInterruptListener)); + cls->defineFunction("setEndListener", _SE(js_cc_SkeletonAnimation_setEndListener)); + cls->defineFunction("setDisposeListener", _SE(js_cc_SkeletonAnimation_setDisposeListener)); + cls->defineFunction("setCompleteListenerNative", _SE(js_cc_SkeletonAnimation_setCompleteListenerNative)); + cls->defineFunction("setEventListener", _SE(js_cc_SkeletonAnimation_setEventListener)); + cls->defineFunction("setTrackStartListener", _SE(js_cc_SkeletonAnimation_setTrackStartListener)); + cls->defineFunction("setTrackInterruptListener", _SE(js_cc_SkeletonAnimation_setTrackInterruptListener)); + cls->defineFunction("setTrackEndListener", _SE(js_cc_SkeletonAnimation_setTrackEndListener)); + cls->defineFunction("setTrackDisposeListener", _SE(js_cc_SkeletonAnimation_setTrackDisposeListener)); + cls->defineFunction("setTrackCompleteListenerNative", _SE(js_cc_SkeletonAnimation_setTrackCompleteListenerNative)); + cls->defineFunction("setTrackEventListener", _SE(js_cc_SkeletonAnimation_setTrackEventListener)); + cls->defineFunction("getState", _SE(js_cc_SkeletonAnimation_getState)); + + + cls->defineStaticFunction("createWithJsonFile", _SE(js_cc_SkeletonAnimation_createWithJsonFile_static)); + cls->defineStaticFunction("createWithBinaryFile", _SE(js_cc_SkeletonAnimation_createWithBinaryFile_static)); + cls->defineStaticFunction("setGlobalTimeScale", _SE(js_cc_SkeletonAnimation_setGlobalTimeScale_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonAnimation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonAnimation_proto = cls->getProto(); + __jsb_cc_SkeletonAnimation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonDataMgr_class = nullptr; +se::Object* __jsb_cc_SkeletonDataMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonDataMgr) + +static bool js_cc_SkeletonDataMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonDataMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::SkeletonDataMgr *)cc::SkeletonDataMgr::getInstance(); + + 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_SkeletonDataMgr_getInstance_static) + +static bool js_new_cc_SkeletonDataMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkeletonDataMgr *result; + result = (cc::SkeletonDataMgr *)new cc::SkeletonDataMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonDataMgr, __jsb_cc_SkeletonDataMgr_class, js_delete_cc_SkeletonDataMgr) + +static bool js_delete_cc_SkeletonDataMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonDataMgr) + +static bool js_cc_SkeletonDataMgr_setDestroyCallback(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonDataMgr *arg1 = (cc::SkeletonDataMgr *) NULL ; + cc::SkeletonDataMgr::destroyCallback arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + + (arg1)->setDestroyCallback(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonDataMgr_setDestroyCallback) + +static bool js_cc_SkeletonDataMgr_getSkeletonDataInfos(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonDataMgr *arg1 = (cc::SkeletonDataMgr *) NULL ; + std::vector< cc::SkeletonDataInfo * > result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonDataMgr const *)arg1)->getSkeletonDataInfos(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonDataMgr_getSkeletonDataInfos) + +bool js_register_cc_SkeletonDataMgr(se::Object* obj) { + auto* cls = se::Class::create("SkeletonDataMgr", obj, nullptr, _SE(js_new_cc_SkeletonDataMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("setDestroyCallback", _SE(js_cc_SkeletonDataMgr_setDestroyCallback)); + cls->defineFunction("getSkeletonDataInfos", _SE(js_cc_SkeletonDataMgr_getSkeletonDataInfos)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_SkeletonDataMgr_getInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonDataMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonDataMgr_proto = cls->getProto(); + __jsb_cc_SkeletonDataMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonCacheAnimation_class = nullptr; +se::Object* __jsb_cc_SkeletonCacheAnimation_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonCacheAnimation) + +static bool js_new_cc_SkeletonCacheAnimation(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if (argc != 2) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2); + return false; + } + + std::string *arg1 = 0 ; + bool arg2 ; + std::string temp1 ; + cc::SkeletonCacheAnimation *result; + + ok &= sevalue_to_native(args[0], &temp1, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg1 = &temp1; + + + ok &= sevalue_to_native(args[1], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + result = (cc::SkeletonCacheAnimation *)new cc::SkeletonCacheAnimation((std::string const &)*arg1,arg2); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonCacheAnimation, __jsb_cc_SkeletonCacheAnimation_class, js_delete_cc_SkeletonCacheAnimation) + +static bool js_delete_cc_SkeletonCacheAnimation(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonCacheAnimation) + +static bool js_cc_SkeletonCacheAnimation_update(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->update(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_update) + +static bool js_cc_SkeletonCacheAnimation_getSkeleton(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + spine::Skeleton *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(s); + if (nullptr == arg1) return true; + result = (spine::Skeleton *)((cc::SkeletonCacheAnimation const *)arg1)->getSkeleton(); + + 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_SkeletonCacheAnimation_getSkeleton) + +static bool js_cc_SkeletonCacheAnimation_setTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setTimeScale(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setTimeScale) + +static bool js_cc_SkeletonCacheAnimation_getTimeScale(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = (float)((cc::SkeletonCacheAnimation const *)arg1)->getTimeScale(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_getTimeScale) + +static bool js_cc_SkeletonCacheAnimation_paused(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->paused(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_paused) + +static bool js_cc_SkeletonCacheAnimation_findBone(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Bone *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(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 = (spine::Bone *)((cc::SkeletonCacheAnimation const *)arg1)->findBone((std::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_SkeletonCacheAnimation_findBone) + +static bool js_cc_SkeletonCacheAnimation_findSlot(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Slot *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(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 = (spine::Slot *)((cc::SkeletonCacheAnimation const *)arg1)->findSlot((std::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_SkeletonCacheAnimation_findSlot) + +static bool js_cc_SkeletonCacheAnimation_setSkin__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->setSkin((std::string const &)*arg2); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setSkin__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + char *arg2 = (char *) NULL ; + ccstd::string temp2 ; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = (char *) temp2.c_str(); + (arg1)->setSkin((char const *)arg2); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setSkin(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 1) { + ok = js_cc_SkeletonCacheAnimation_setSkin__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 1) { + ok = js_cc_SkeletonCacheAnimation_setSkin__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setSkin) + +static bool js_cc_SkeletonCacheAnimation_getAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + spine::Attachment *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(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (spine::Attachment *)((cc::SkeletonCacheAnimation const *)arg1)->getAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_getAttachment) + +static bool js_cc_SkeletonCacheAnimation_setAttachment__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string temp2 ; + std::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &temp2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg2 = &temp2; + + + ok &= sevalue_to_native(args[1], &temp3, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = &temp3; + + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(std::string const &)*arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setAttachment__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + char *arg3 = (char *) NULL ; + std::string temp2 ; + ccstd::string temp3 ; + bool result; + + arg1 = SE_THIS_OBJECT(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); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + arg3 = (char *) temp3.c_str(); + result = (bool)(arg1)->setAttachment((std::string const &)*arg2,(char const *)arg3); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_setAttachment(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 2) { + ok = js_cc_SkeletonCacheAnimation_setAttachment__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonCacheAnimation_setAttachment__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setAttachment) + +static bool js_cc_SkeletonCacheAnimation_setColor(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + + if(argc != 4) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setColor(arg2,arg3,arg4,arg5); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setColor) + +static bool js_cc_SkeletonCacheAnimation_setBatchEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setBatchEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setBatchEnabled) + +static bool js_cc_SkeletonCacheAnimation_setAttachEnabled(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setAttachEnabled(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setAttachEnabled) + +static bool js_cc_SkeletonCacheAnimation_setOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setOpacityModifyRGB(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setOpacityModifyRGB) + +static bool js_cc_SkeletonCacheAnimation_isOpacityModifyRGB(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) 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(s); + if (nullptr == arg1) return true; + result = (bool)((cc::SkeletonCacheAnimation const *)arg1)->isOpacityModifyRGB(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject()); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_isOpacityModifyRGB) + +static bool js_cc_SkeletonCacheAnimation_beginSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->beginSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_beginSchedule) + +static bool js_cc_SkeletonCacheAnimation_stopSchedule(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->stopSchedule(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_stopSchedule) + +static bool js_cc_SkeletonCacheAnimation_onEnable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onEnable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_onEnable) + +static bool js_cc_SkeletonCacheAnimation_onDisable(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->onDisable(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_onDisable) + +static bool js_cc_SkeletonCacheAnimation_setUseTint(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + bool arg2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setUseTint(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setUseTint) + +static bool js_cc_SkeletonCacheAnimation_setAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::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(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)->setAnimation((std::string const &)*arg2,arg3); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setAnimation) + +static bool js_cc_SkeletonCacheAnimation_addAnimation__SWIG_0(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + float arg4 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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"); + + ok &= sevalue_to_native(args[2], &arg4, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->addAnimation((std::string const &)*arg2,arg3,arg4); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_addAnimation__SWIG_1(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + bool arg3 ; + std::string temp2 ; + + arg1 = SE_THIS_OBJECT(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)->addAnimation((std::string const &)*arg2,arg3); + + + return true; +} + +static bool js_cc_SkeletonCacheAnimation_addAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + + if (argc == 3) { + ok = js_cc_SkeletonCacheAnimation_addAnimation__SWIG_0(s); + if (ok) { + return true; + } + } + if (argc == 2) { + ok = js_cc_SkeletonCacheAnimation_addAnimation__SWIG_1(s); + if (ok) { + return true; + } + } + SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc); + return false; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_addAnimation) + +static bool js_cc_SkeletonCacheAnimation_findAnimation(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + spine::Animation *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(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 = (spine::Animation *)((cc::SkeletonCacheAnimation const *)arg1)->findAnimation((std::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_SkeletonCacheAnimation_findAnimation) + +static bool js_cc_SkeletonCacheAnimation_setStartListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::SkeletonCacheAnimation::CacheFrameEvent *arg2 = 0 ; + cc::SkeletonCacheAnimation::CacheFrameEvent temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setStartListener((cc::SkeletonCacheAnimation::CacheFrameEvent const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setStartListener) + +static bool js_cc_SkeletonCacheAnimation_setEndListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::SkeletonCacheAnimation::CacheFrameEvent *arg2 = 0 ; + cc::SkeletonCacheAnimation::CacheFrameEvent temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setEndListener((cc::SkeletonCacheAnimation::CacheFrameEvent const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setEndListener) + +static bool js_cc_SkeletonCacheAnimation_setCompleteListener(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::SkeletonCacheAnimation::CacheFrameEvent *arg2 = 0 ; + cc::SkeletonCacheAnimation::CacheFrameEvent temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->setCompleteListener((cc::SkeletonCacheAnimation::CacheFrameEvent const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setCompleteListener) + +static bool js_cc_SkeletonCacheAnimation_updateAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->updateAnimationCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_updateAnimationCache) + +static bool js_cc_SkeletonCacheAnimation_updateAllAnimationCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->updateAllAnimationCache(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_updateAllAnimationCache) + +static bool js_cc_SkeletonCacheAnimation_setToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setToSetupPose) + +static bool js_cc_SkeletonCacheAnimation_setBonesToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setBonesToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setBonesToSetupPose) + +static bool js_cc_SkeletonCacheAnimation_setSlotsToSetupPose(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + (arg1)->setSlotsToSetupPose(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setSlotsToSetupPose) + +static bool js_cc_SkeletonCacheAnimation_getSharedBufferOffset(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + se_object_ptr result; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + result = ((cc::SkeletonCacheAnimation const *)arg1)->getSharedBufferOffset(); + + ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); + + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_getSharedBufferOffset) + +static bool js_cc_SkeletonCacheAnimation_setMaterial(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::Material *arg2 = (cc::Material *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setMaterial(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setMaterial) + +static bool js_cc_SkeletonCacheAnimation_setRenderEntity(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheAnimation *arg1 = (cc::SkeletonCacheAnimation *) NULL ; + cc::RenderEntity *arg2 = (cc::RenderEntity *) NULL ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(s); + if (nullptr == arg1) return true; + + ok &= sevalue_to_native(args[0], &arg2, s.thisObject()); + SE_PRECONDITION2(ok, false, "Error processing arguments"); + (arg1)->setRenderEntity(arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheAnimation_setRenderEntity) + +bool js_register_cc_SkeletonCacheAnimation(se::Object* obj) { + auto* cls = se::Class::create("SkeletonCacheAnimation", obj, nullptr, _SE(js_new_cc_SkeletonCacheAnimation)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("update", _SE(js_cc_SkeletonCacheAnimation_update)); + cls->defineFunction("getSkeleton", _SE(js_cc_SkeletonCacheAnimation_getSkeleton)); + cls->defineFunction("setTimeScale", _SE(js_cc_SkeletonCacheAnimation_setTimeScale)); + cls->defineFunction("getTimeScale", _SE(js_cc_SkeletonCacheAnimation_getTimeScale)); + cls->defineFunction("paused", _SE(js_cc_SkeletonCacheAnimation_paused)); + cls->defineFunction("findBone", _SE(js_cc_SkeletonCacheAnimation_findBone)); + cls->defineFunction("findSlot", _SE(js_cc_SkeletonCacheAnimation_findSlot)); + cls->defineFunction("setSkin", _SE(js_cc_SkeletonCacheAnimation_setSkin)); + cls->defineFunction("getAttachment", _SE(js_cc_SkeletonCacheAnimation_getAttachment)); + cls->defineFunction("setAttachment", _SE(js_cc_SkeletonCacheAnimation_setAttachment)); + cls->defineFunction("setColor", _SE(js_cc_SkeletonCacheAnimation_setColor)); + cls->defineFunction("setBatchEnabled", _SE(js_cc_SkeletonCacheAnimation_setBatchEnabled)); + cls->defineFunction("setAttachEnabled", _SE(js_cc_SkeletonCacheAnimation_setAttachEnabled)); + cls->defineFunction("setOpacityModifyRGB", _SE(js_cc_SkeletonCacheAnimation_setOpacityModifyRGB)); + cls->defineFunction("isOpacityModifyRGB", _SE(js_cc_SkeletonCacheAnimation_isOpacityModifyRGB)); + cls->defineFunction("beginSchedule", _SE(js_cc_SkeletonCacheAnimation_beginSchedule)); + cls->defineFunction("stopSchedule", _SE(js_cc_SkeletonCacheAnimation_stopSchedule)); + cls->defineFunction("onEnable", _SE(js_cc_SkeletonCacheAnimation_onEnable)); + cls->defineFunction("onDisable", _SE(js_cc_SkeletonCacheAnimation_onDisable)); + cls->defineFunction("setUseTint", _SE(js_cc_SkeletonCacheAnimation_setUseTint)); + cls->defineFunction("setAnimation", _SE(js_cc_SkeletonCacheAnimation_setAnimation)); + cls->defineFunction("addAnimation", _SE(js_cc_SkeletonCacheAnimation_addAnimation)); + cls->defineFunction("findAnimation", _SE(js_cc_SkeletonCacheAnimation_findAnimation)); + cls->defineFunction("setStartListener", _SE(js_cc_SkeletonCacheAnimation_setStartListener)); + cls->defineFunction("setEndListener", _SE(js_cc_SkeletonCacheAnimation_setEndListener)); + cls->defineFunction("setCompleteListener", _SE(js_cc_SkeletonCacheAnimation_setCompleteListener)); + cls->defineFunction("updateAnimationCache", _SE(js_cc_SkeletonCacheAnimation_updateAnimationCache)); + cls->defineFunction("updateAllAnimationCache", _SE(js_cc_SkeletonCacheAnimation_updateAllAnimationCache)); + cls->defineFunction("setToSetupPose", _SE(js_cc_SkeletonCacheAnimation_setToSetupPose)); + cls->defineFunction("setBonesToSetupPose", _SE(js_cc_SkeletonCacheAnimation_setBonesToSetupPose)); + cls->defineFunction("setSlotsToSetupPose", _SE(js_cc_SkeletonCacheAnimation_setSlotsToSetupPose)); + cls->defineFunction("getSharedBufferOffset", _SE(js_cc_SkeletonCacheAnimation_getSharedBufferOffset)); + cls->defineFunction("setMaterial", _SE(js_cc_SkeletonCacheAnimation_setMaterial)); + cls->defineFunction("setRenderEntity", _SE(js_cc_SkeletonCacheAnimation_setRenderEntity)); + + + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonCacheAnimation)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonCacheAnimation_proto = cls->getProto(); + __jsb_cc_SkeletonCacheAnimation_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + +se::Class* __jsb_cc_SkeletonCacheMgr_class = nullptr; +se::Object* __jsb_cc_SkeletonCacheMgr_proto = nullptr; +SE_DECLARE_FINALIZE_FUNC(js_delete_cc_SkeletonCacheMgr) + +static bool js_cc_SkeletonCacheMgr_getInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheMgr *result = 0 ; + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + result = (cc::SkeletonCacheMgr *)cc::SkeletonCacheMgr::getInstance(); + + 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_SkeletonCacheMgr_getInstance_static) + +static bool js_cc_SkeletonCacheMgr_destroyInstance_static(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + if(argc != 0) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; + } + cc::SkeletonCacheMgr::destroyInstance(); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheMgr_destroyInstance_static) + +static bool js_cc_SkeletonCacheMgr_removeSkeletonCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheMgr *arg1 = (cc::SkeletonCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + + if(argc != 1) { + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; + } + arg1 = SE_THIS_OBJECT(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)->removeSkeletonCache((std::string const &)*arg2); + + + return true; +} +SE_BIND_FUNC(js_cc_SkeletonCacheMgr_removeSkeletonCache) + +static bool js_cc_SkeletonCacheMgr_buildSkeletonCache(se::State& s) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + cc::SkeletonCacheMgr *arg1 = (cc::SkeletonCacheMgr *) NULL ; + std::string *arg2 = 0 ; + std::string temp2 ; + cc::SkeletonCache *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(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::SkeletonCache *)(arg1)->buildSkeletonCache((std::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_SkeletonCacheMgr_buildSkeletonCache) + +static bool js_new_cc_SkeletonCacheMgr(se::State& s) // NOLINT(readability-identifier-naming) +{ + CC_UNUSED bool ok = true; + const auto& args = s.args(); + size_t argc = args.size(); + + cc::SkeletonCacheMgr *result; + result = (cc::SkeletonCacheMgr *)new cc::SkeletonCacheMgr(); + + + auto *ptr = JSB_MAKE_PRIVATE_OBJECT_WITH_INSTANCE(result); + s.thisObject()->setPrivateObject(ptr); + return true; +} +SE_BIND_CTOR(js_new_cc_SkeletonCacheMgr, __jsb_cc_SkeletonCacheMgr_class, js_delete_cc_SkeletonCacheMgr) + +static bool js_delete_cc_SkeletonCacheMgr(se::State& s) +{ + return true; +} +SE_BIND_FINALIZE_FUNC(js_delete_cc_SkeletonCacheMgr) + +bool js_register_cc_SkeletonCacheMgr(se::Object* obj) { + auto* cls = se::Class::create("SkeletonCacheMgr", obj, nullptr, _SE(js_new_cc_SkeletonCacheMgr)); + + cls->defineStaticProperty("__isJSB", se::Value(true), se::PropertyAttribute::READ_ONLY | se::PropertyAttribute::DONT_ENUM | se::PropertyAttribute::DONT_DELETE); + + cls->defineFunction("removeSkeletonCache", _SE(js_cc_SkeletonCacheMgr_removeSkeletonCache)); + cls->defineFunction("buildSkeletonCache", _SE(js_cc_SkeletonCacheMgr_buildSkeletonCache)); + + + cls->defineStaticFunction("getInstance", _SE(js_cc_SkeletonCacheMgr_getInstance_static)); + cls->defineStaticFunction("destroyInstance", _SE(js_cc_SkeletonCacheMgr_destroyInstance_static)); + + + cls->defineFinalizeFunction(_SE(js_delete_cc_SkeletonCacheMgr)); + + + cls->install(); + JSBClassType::registerClass(cls); + + __jsb_cc_SkeletonCacheMgr_proto = cls->getProto(); + __jsb_cc_SkeletonCacheMgr_class = cls; + se::ScriptEngine::getInstance()->clearException(); + return true; +} + + + + +bool register_all_spine(se::Object* obj) { + // Get the ns + se::Value nsVal; + if (!obj->getProperty("spine", &nsVal, true)) + { + se::HandleObject jsobj(se::Object::createPlainObject()); + nsVal.setObject(jsobj); + obj->setProperty("spine", nsVal); + } + se::Object* ns = nsVal.toObject(); + /* Register classes */ + js_register_spine_MathUtil(ns); + js_register_spine_Interpolation(ns); + js_register_spine_PowInterpolation(ns); + js_register_spine_PowOutInterpolation(ns); + js_register_spine_Timeline(ns); + js_register_spine_Animation(ns); + js_register_spine_AnimationStateListenerObject(ns); + js_register_spine_TrackEntry(ns); + js_register_spine_EventQueueEntry(ns); + js_register_spine_EventQueue(ns); + js_register_spine_AnimationState(ns); + js_register_spine_AnimationStateData(ns); + js_register_spine_Attachment(ns); + js_register_spine_AttachmentTimeline(ns); + js_register_spine_VertexAttachment(ns); + js_register_spine_BoundingBoxAttachment(ns); + js_register_spine_Bone(ns); + js_register_spine_BoneData(ns); + js_register_spine_ClippingAttachment(ns); + js_register_spine_Color(ns); + js_register_spine_CurveTimeline(ns); + js_register_spine_ColorTimeline(ns); + js_register_spine_DeformTimeline(ns); + js_register_spine_DrawOrderTimeline(ns); + js_register_spine_Event(ns); + js_register_spine_EventData(ns); + js_register_spine_EventTimeline(ns); + js_register_spine_ConstraintData(ns); + js_register_spine_IkConstraint(ns); + js_register_spine_IkConstraintData(ns); + js_register_spine_IkConstraintTimeline(ns); + js_register_spine_MeshAttachment(ns); + js_register_spine_PathAttachment(ns); + js_register_spine_PathConstraint(ns); + js_register_spine_PathConstraintData(ns); + js_register_spine_PathConstraintMixTimeline(ns); + js_register_spine_PathConstraintPositionTimeline(ns); + js_register_spine_PathConstraintSpacingTimeline(ns); + js_register_spine_PointAttachment(ns); + js_register_spine_RegionAttachment(ns); + js_register_spine_TranslateTimeline(ns); + js_register_spine_TwoColorTimeline(ns); + js_register_spine_RotateTimeline(ns); + js_register_spine_ScaleTimeline(ns); + js_register_spine_ShearTimeline(ns); + js_register_spine_Skeleton(ns); + js_register_spine_Slot(ns); + js_register_spine_Skin(ns); + js_register_spine_Skin_AttachmentMap(ns); + js_register_spine_Skin_AttachmentMap_Entry(ns); + js_register_spine_Skin_AttachmentMap_Entries(ns); + js_register_spine_SkeletonBounds(ns); + js_register_spine_Polygon(ns); + js_register_spine_SkeletonData(ns); + js_register_spine_SlotData(ns); + js_register_spine_SkeletonBinary(ns); + js_register_spine_AttachmentLoader(ns); + js_register_spine_AtlasPage(ns); + js_register_spine_AtlasRegion(ns); + js_register_spine_Atlas(ns); + js_register_spine_TextureLoader(ns); + js_register_spine_TransformConstraint(ns); + js_register_spine_TransformConstraintData(ns); + js_register_spine_TransformConstraintTimeline(ns); + js_register_spine_VertexEffect(ns); + js_register_spine_JitterVertexEffect(ns); + js_register_spine_SwirlVertexEffect(ns); + js_register_cc_VertexEffectDelegate(ns); + js_register_cc_SkeletonRenderer(ns); + js_register_cc_CacheEventInfo(ns); + js_register_cc_SkeletonAnimation(ns); + js_register_cc_SkeletonDataMgr(ns); + js_register_cc_SkeletonCacheAnimation(ns); + js_register_cc_SkeletonCacheMgr(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 diff --git a/native/build_android/generated/cocos/bindings/auto/temp/jsb_spine_3_8_auto.h b/native/build_android/generated/cocos/bindings/auto/temp/jsb_spine_3_8_auto.h new file mode 100644 index 0000000000..0186d68505 --- /dev/null +++ b/native/build_android/generated/cocos/bindings/auto/temp/jsb_spine_3_8_auto.h @@ -0,0 +1,435 @@ +// 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. +****************************************************************************/ + +#pragma once +#include "bindings/jswrapper/SeApi.h" +#include "bindings/manual/jsb_conversions.h" +#include "editor-support/spine-creator-support/spine-cocos2dx.h" +#include "editor-support/spine-creator-support/Vector2.h" + + + +bool register_all_spine(se::Object* obj); + + +JSB_REGISTER_OBJECT_TYPE(spine::MathUtil); +extern se::Object *__jsb_spine_MathUtil_proto; // NOLINT +extern se::Class * __jsb_spine_MathUtil_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Interpolation); +extern se::Object *__jsb_spine_Interpolation_proto; // NOLINT +extern se::Class * __jsb_spine_Interpolation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::Interpolation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::PowInterpolation); +extern se::Object *__jsb_spine_PowInterpolation_proto; // NOLINT +extern se::Class * __jsb_spine_PowInterpolation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowInterpolation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::PowOutInterpolation); +extern se::Object *__jsb_spine_PowOutInterpolation_proto; // NOLINT +extern se::Class * __jsb_spine_PowOutInterpolation_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::PowOutInterpolation * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::Timeline); +extern se::Object *__jsb_spine_Timeline_proto; // NOLINT +extern se::Class * __jsb_spine_Timeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Animation); +extern se::Object *__jsb_spine_Animation_proto; // NOLINT +extern se::Class * __jsb_spine_Animation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AnimationStateListenerObject); +extern se::Object *__jsb_spine_AnimationStateListenerObject_proto; // NOLINT +extern se::Class * __jsb_spine_AnimationStateListenerObject_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TrackEntry); +extern se::Object *__jsb_spine_TrackEntry_proto; // NOLINT +extern se::Class * __jsb_spine_TrackEntry_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventQueueEntry); +extern se::Object *__jsb_spine_EventQueueEntry_proto; // NOLINT +extern se::Class * __jsb_spine_EventQueueEntry_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventQueue); +extern se::Object *__jsb_spine_EventQueue_proto; // NOLINT +extern se::Class * __jsb_spine_EventQueue_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AnimationState); +extern se::Object *__jsb_spine_AnimationState_proto; // NOLINT +extern se::Class * __jsb_spine_AnimationState_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AnimationStateData); +extern se::Object *__jsb_spine_AnimationStateData_proto; // NOLINT +extern se::Class * __jsb_spine_AnimationStateData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Attachment); +extern se::Object *__jsb_spine_Attachment_proto; // NOLINT +extern se::Class * __jsb_spine_Attachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AttachmentTimeline); +extern se::Object *__jsb_spine_AttachmentTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_AttachmentTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::VertexAttachment); +extern se::Object *__jsb_spine_VertexAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_VertexAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::BoundingBoxAttachment); +extern se::Object *__jsb_spine_BoundingBoxAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_BoundingBoxAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Bone); +extern se::Object *__jsb_spine_Bone_proto; // NOLINT +extern se::Class * __jsb_spine_Bone_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::BoneData); +extern se::Object *__jsb_spine_BoneData_proto; // NOLINT +extern se::Class * __jsb_spine_BoneData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ClippingAttachment); +extern se::Object *__jsb_spine_ClippingAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_ClippingAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Color); +extern se::Object *__jsb_spine_Color_proto; // NOLINT +extern se::Class * __jsb_spine_Color_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::CurveTimeline); +extern se::Object *__jsb_spine_CurveTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_CurveTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ColorTimeline); +extern se::Object *__jsb_spine_ColorTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_ColorTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::DeformTimeline); +extern se::Object *__jsb_spine_DeformTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_DeformTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::DrawOrderTimeline); +extern se::Object *__jsb_spine_DrawOrderTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_DrawOrderTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Event); +extern se::Object *__jsb_spine_Event_proto; // NOLINT +extern se::Class * __jsb_spine_Event_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventData); +extern se::Object *__jsb_spine_EventData_proto; // NOLINT +extern se::Class * __jsb_spine_EventData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::EventTimeline); +extern se::Object *__jsb_spine_EventTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_EventTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ConstraintData); +extern se::Object *__jsb_spine_ConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_ConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::IkConstraint); +extern se::Object *__jsb_spine_IkConstraint_proto; // NOLINT +extern se::Class * __jsb_spine_IkConstraint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::IkConstraintData); +extern se::Object *__jsb_spine_IkConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_IkConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::IkConstraintTimeline); +extern se::Object *__jsb_spine_IkConstraintTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_IkConstraintTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::MeshAttachment); +extern se::Object *__jsb_spine_MeshAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_MeshAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathAttachment); +extern se::Object *__jsb_spine_PathAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_PathAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraint); +extern se::Object *__jsb_spine_PathConstraint_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintData); +extern se::Object *__jsb_spine_PathConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintMixTimeline); +extern se::Object *__jsb_spine_PathConstraintMixTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintMixTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintPositionTimeline); +extern se::Object *__jsb_spine_PathConstraintPositionTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintPositionTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PathConstraintSpacingTimeline); +extern se::Object *__jsb_spine_PathConstraintSpacingTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_PathConstraintSpacingTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::PointAttachment); +extern se::Object *__jsb_spine_PointAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_PointAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::RegionAttachment); +extern se::Object *__jsb_spine_RegionAttachment_proto; // NOLINT +extern se::Class * __jsb_spine_RegionAttachment_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TranslateTimeline); +extern se::Object *__jsb_spine_TranslateTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_TranslateTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TwoColorTimeline); +extern se::Object *__jsb_spine_TwoColorTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_TwoColorTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::RotateTimeline); +extern se::Object *__jsb_spine_RotateTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_RotateTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ScaleTimeline); +extern se::Object *__jsb_spine_ScaleTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_ScaleTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::ShearTimeline); +extern se::Object *__jsb_spine_ShearTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_ShearTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skeleton); +extern se::Object *__jsb_spine_Skeleton_proto; // NOLINT +extern se::Class * __jsb_spine_Skeleton_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Slot); +extern se::Object *__jsb_spine_Slot_proto; // NOLINT +extern se::Class * __jsb_spine_Slot_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin::AttachmentMap::Entry); +extern se::Object *__jsb_spine_Skin_AttachmentMap_Entry_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_AttachmentMap_Entry_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, spine::Skin::AttachmentMap::Entry * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin::AttachmentMap::Entries); +extern se::Object *__jsb_spine_Skin_AttachmentMap_Entries_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_AttachmentMap_Entries_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin::AttachmentMap); +extern se::Object *__jsb_spine_Skin_AttachmentMap_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_AttachmentMap_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Skin); +extern se::Object *__jsb_spine_Skin_proto; // NOLINT +extern se::Class * __jsb_spine_Skin_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SkeletonBounds); +extern se::Object *__jsb_spine_SkeletonBounds_proto; // NOLINT +extern se::Class * __jsb_spine_SkeletonBounds_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Polygon); +extern se::Object *__jsb_spine_Polygon_proto; // NOLINT +extern se::Class * __jsb_spine_Polygon_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SkeletonData); +extern se::Object *__jsb_spine_SkeletonData_proto; // NOLINT +extern se::Class * __jsb_spine_SkeletonData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SlotData); +extern se::Object *__jsb_spine_SlotData_proto; // NOLINT +extern se::Class * __jsb_spine_SlotData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SkeletonBinary); +extern se::Object *__jsb_spine_SkeletonBinary_proto; // NOLINT +extern se::Class * __jsb_spine_SkeletonBinary_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AttachmentLoader); +extern se::Object *__jsb_spine_AttachmentLoader_proto; // NOLINT +extern se::Class * __jsb_spine_AttachmentLoader_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AtlasPage); +extern se::Object *__jsb_spine_AtlasPage_proto; // NOLINT +extern se::Class * __jsb_spine_AtlasPage_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::AtlasRegion); +extern se::Object *__jsb_spine_AtlasRegion_proto; // NOLINT +extern se::Class * __jsb_spine_AtlasRegion_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::Atlas); +extern se::Object *__jsb_spine_Atlas_proto; // NOLINT +extern se::Class * __jsb_spine_Atlas_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TextureLoader); +extern se::Object *__jsb_spine_TextureLoader_proto; // NOLINT +extern se::Class * __jsb_spine_TextureLoader_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TransformConstraint); +extern se::Object *__jsb_spine_TransformConstraint_proto; // NOLINT +extern se::Class * __jsb_spine_TransformConstraint_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TransformConstraintData); +extern se::Object *__jsb_spine_TransformConstraintData_proto; // NOLINT +extern se::Class * __jsb_spine_TransformConstraintData_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::TransformConstraintTimeline); +extern se::Object *__jsb_spine_TransformConstraintTimeline_proto; // NOLINT +extern se::Class * __jsb_spine_TransformConstraintTimeline_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::VertexEffect); +extern se::Object *__jsb_spine_VertexEffect_proto; // NOLINT +extern se::Class * __jsb_spine_VertexEffect_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::JitterVertexEffect); +extern se::Object *__jsb_spine_JitterVertexEffect_proto; // NOLINT +extern se::Class * __jsb_spine_JitterVertexEffect_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(spine::SwirlVertexEffect); +extern se::Object *__jsb_spine_SwirlVertexEffect_proto; // NOLINT +extern se::Class * __jsb_spine_SwirlVertexEffect_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::VertexEffectDelegate); +extern se::Object *__jsb_cc_VertexEffectDelegate_proto; // NOLINT +extern se::Class * __jsb_cc_VertexEffectDelegate_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonRenderer); +extern se::Object *__jsb_cc_SkeletonRenderer_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonRenderer_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::CacheEventInfo); +extern se::Object *__jsb_cc_CacheEventInfo_proto; // NOLINT +extern se::Class * __jsb_cc_CacheEventInfo_class; // NOLINT + + +template<> +bool sevalue_to_native(const se::Value &from, cc::CacheEventInfo * to, se::Object *ctx); + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonAnimation); +extern se::Object *__jsb_cc_SkeletonAnimation_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonAnimation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonDataMgr); +extern se::Object *__jsb_cc_SkeletonDataMgr_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonDataMgr_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonCacheAnimation); +extern se::Object *__jsb_cc_SkeletonCacheAnimation_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonCacheAnimation_class; // NOLINT + + +JSB_REGISTER_OBJECT_TYPE(cc::SkeletonCacheMgr); +extern se::Object *__jsb_cc_SkeletonCacheMgr_proto; // NOLINT +extern se::Class * __jsb_cc_SkeletonCacheMgr_class; // NOLINT + +// clang-format on diff --git a/native/build_android/libandroid_platform.a b/native/build_android/libandroid_platform.a new file mode 100644 index 0000000000..5f5e7008ea Binary files /dev/null and b/native/build_android/libandroid_platform.a differ diff --git a/native/build_android/libccbindings.a b/native/build_android/libccbindings.a new file mode 100644 index 0000000000..0ff154c82a Binary files /dev/null and b/native/build_android/libccbindings.a differ diff --git a/native/build_android/libccfilesystem.a b/native/build_android/libccfilesystem.a new file mode 100644 index 0000000000..2251034f28 Binary files /dev/null and b/native/build_android/libccfilesystem.a differ diff --git a/native/build_android/libcclog.a b/native/build_android/libcclog.a new file mode 100644 index 0000000000..aa6ef46acd Binary files /dev/null and b/native/build_android/libcclog.a differ diff --git a/native/build_android/libccunzip.a b/native/build_android/libccunzip.a new file mode 100644 index 0000000000..ea0b13e477 Binary files /dev/null and b/native/build_android/libccunzip.a differ diff --git a/native/build_android/libccutils.a b/native/build_android/libccutils.a new file mode 100644 index 0000000000..ce2048bc75 Binary files /dev/null and b/native/build_android/libccutils.a differ diff --git a/native/build_android/libcocos_jni.a b/native/build_android/libcocos_jni.a new file mode 100644 index 0000000000..64ee1363a1 Binary files /dev/null and b/native/build_android/libcocos_jni.a differ diff --git a/native/build_android/pvmp3dec_tmp_def.h b/native/build_android/pvmp3dec_tmp_def.h new file mode 100644 index 0000000000..dc51efbd37 --- /dev/null +++ b/native/build_android/pvmp3dec_tmp_def.h @@ -0,0 +1,2 @@ +#pragma once +#define OSCL_UNUSED_ARG(x) (void)(x) \ No newline at end of file diff --git a/native/build_quick_test/pvmp3dec_tmp_def.h b/native/build_quick_test/pvmp3dec_tmp_def.h new file mode 100644 index 0000000000..dc51efbd37 --- /dev/null +++ b/native/build_quick_test/pvmp3dec_tmp_def.h @@ -0,0 +1,2 @@ +#pragma once +#define OSCL_UNUSED_ARG(x) (void)(x) \ No newline at end of file diff --git a/native/cocos/base/std/hash/hash.h b/native/cocos/base/std/hash/hash.h index 7013cd6830..94479ce5f9 100644 --- a/native/cocos/base/std/hash/hash.h +++ b/native/cocos/base/std/hash/hash.h @@ -83,6 +83,13 @@ # define CCSTD_HASH_CXX17 0 #endif +// Define BOOST_NO_CXX98_FUNCTION_BASE for C++17 and later (std::unary_function removed) +#if CCSTD_HASH_CXX17 +# if !defined(BOOST_NO_CXX98_FUNCTION_BASE) +# define BOOST_NO_CXX98_FUNCTION_BASE +# endif +#endif + #if CCSTD_HASH_CXX17 && defined(__has_include) # if !defined(CCSTD_HASH_HAS_STRING_VIEW) && __has_include() # define CCSTD_HASH_HAS_STRING_VIEW 1 diff --git a/native/cocos/bindings/jswrapper/Object.h b/native/cocos/bindings/jswrapper/Object.h index 952a29f9ae..f02b845297 100644 --- a/native/cocos/bindings/jswrapper/Object.h +++ b/native/cocos/bindings/jswrapper/Object.h @@ -49,4 +49,8 @@ #if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_JSVM #include "jsvm/Object.h" +#endif + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + #include "hermes/Object.h" #endif \ No newline at end of file diff --git a/native/cocos/bindings/jswrapper/SeApi.h b/native/cocos/bindings/jswrapper/SeApi.h index 87d5a0aaff..1f03f51e08 100644 --- a/native/cocos/bindings/jswrapper/SeApi.h +++ b/native/cocos/bindings/jswrapper/SeApi.h @@ -51,6 +51,10 @@ #include "jsvm/SeApi.h" #endif +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + #include "hermes/SeApi.h" +#endif + #include "HandleObject.h" #include "Object.h" #include "State.h" diff --git a/native/cocos/bindings/jswrapper/State.h b/native/cocos/bindings/jswrapper/State.h index 258042818a..b4a2f2b2ed 100644 --- a/native/cocos/bindings/jswrapper/State.h +++ b/native/cocos/bindings/jswrapper/State.h @@ -29,6 +29,10 @@ #include "PrivateObject.h" #include "Value.h" +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + #include +#endif + namespace se { class Object; @@ -97,6 +101,28 @@ class State final { } } +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + State(facebook::jsi::Runtime* rt, + const facebook::jsi::Value* thisVal, + const facebook::jsi::Value* argv, + size_t argc) : _thisObject(nullptr), _args(nullptr), _argc(argc), _rt(rt) { + if (thisVal != nullptr) { + _seThisVal.fromJsiValue(*rt, *thisVal); + _thisObject = _seThisVal.toObject(); + } + if (argv != nullptr && argc > 0) { + _seArgs.reserve(argc); + for (size_t i = 0; i < argc; ++i) { + se::Value val; + val.fromJsiValue(*rt, argv[i]); + _seArgs.push_back(std::move(val)); + } + _args = &_seArgs; + if (_thisObject != nullptr) _thisObject->incRef(); + } + } +#endif + // Disable copy/move constructor, copy/move assigment State(const State &) = delete; State(State &&) noexcept = delete; @@ -107,5 +133,12 @@ class State final { Object *_thisObject{nullptr}; // weak ref const ValueArray *_args{nullptr}; // weak ref Value _retVal; // weak ref + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + size_t _argc{0}; + facebook::jsi::Runtime* _rt{nullptr}; + se::Value _seThisVal; + mutable ccstd::vector _seArgs; +#endif }; } // namespace se diff --git a/native/cocos/bindings/jswrapper/Value.cpp b/native/cocos/bindings/jswrapper/Value.cpp index 447cb6540d..3935b701dc 100644 --- a/native/cocos/bindings/jswrapper/Value.cpp +++ b/native/cocos/bindings/jswrapper/Value.cpp @@ -573,4 +573,60 @@ double Value::toNumber() const { return toDouble(); } +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES +facebook::jsi::Value Value::toJsiValue(facebook::jsi::Runtime& rt) const { + switch (_type) { + case Type::Undefined: + return facebook::jsi::Value::undefined(); + case Type::Null: + return facebook::jsi::Value::null(); + case Type::Boolean: + return facebook::jsi::Value(_u._boolean); + case Type::Number: + return facebook::jsi::Value(rt, _u._number); + case Type::String: + return facebook::jsi::Value(rt, facebook::jsi::String::createFromUtf8(rt, *_u._string)); + case Type::BigInt: + return facebook::jsi::Value(rt, static_cast(_u._bigint)); + case Type::Object: + if (_u._object != nullptr) { + const facebook::jsi::Object& jsObj = _u._object->toJsiObject(rt); + return facebook::jsi::Value(rt, jsObj); + } + return facebook::jsi::Value::null(); + default: + return facebook::jsi::Value::undefined(); + } +} + +void Value::fromJsiValue(facebook::jsi::Runtime& rt, const facebook::jsi::Value& val) { + reset(Type::Undefined); + if (val.isUndefined()) { + return; + } + if (val.isNull()) { + setNull(); + return; + } + if (val.isBool()) { + setBoolean(val.getBool()); + return; + } + if (val.isNumber()) { + setNumber(val.getNumber()); + return; + } + if (val.isString()) { + setString(val.getString(rt).utf8(rt)); + return; + } + if (val.isObject()) { + facebook::jsi::Object jsObj = val.getObject(rt); + se::Object* obj = se::Object::createFromJsiObject(rt, std::move(jsObj)); + setObject(obj); + return; + } +} +#endif + } // namespace se diff --git a/native/cocos/bindings/jswrapper/Value.h b/native/cocos/bindings/jswrapper/Value.h index 553a8fbc5f..4eea2e3b6d 100644 --- a/native/cocos/bindings/jswrapper/Value.h +++ b/native/cocos/bindings/jswrapper/Value.h @@ -25,12 +25,17 @@ #pragma once +#include "config.h" #include #include "HandleObject.h" #include "base/Macros.h" #include "base/std/container/string.h" #include "base/std/container/vector.h" +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + #include +#endif + namespace se { class Object; @@ -474,6 +479,11 @@ class Value final { return static_cast(toUint64()); } +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + facebook::jsi::Value toJsiValue(facebook::jsi::Runtime& rt) const; + void fromJsiValue(facebook::jsi::Runtime& rt, const facebook::jsi::Value& val); +#endif + private: explicit Value(Type type); void reset(Type type); diff --git a/native/cocos/bindings/jswrapper/config.h b/native/cocos/bindings/jswrapper/config.h index 12c415ebdd..20c60cdd34 100644 --- a/native/cocos/bindings/jswrapper/config.h +++ b/native/cocos/bindings/jswrapper/config.h @@ -29,17 +29,24 @@ #include "base/Log.h" -#define SCRIPT_ENGINE_NONE 0 -#define SCRIPT_ENGINE_SM 1 -#define SCRIPT_ENGINE_V8 2 -#define SCRIPT_ENGINE_NAPI 5 -#define SCRIPT_ENGINE_JSVM 6 +#define SCRIPT_ENGINE_NONE 0 +#define SCRIPT_ENGINE_SM 1 +#define SCRIPT_ENGINE_V8 2 +#define SCRIPT_ENGINE_NAPI 5 +#define SCRIPT_ENGINE_JSVM 6 +#define SCRIPT_ENGINE_HERMES 7 #ifndef SCRIPT_ENGINE_TYPE #if CC_PLATFORM == CC_PLATFORM_OPENHARMONY #define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_NAPI #else - #define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_V8 + // Default: V8. Override with -DSCRIPT_ENGINE_TYPE=7 (HERMES) in CMake + // when running inside a React Native Hermes JSI context. + #if defined(USE_SE_HERMES) && USE_SE_HERMES == 1 + #define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_HERMES + #else + #define SCRIPT_ENGINE_TYPE SCRIPT_ENGINE_V8 + #endif #endif #endif diff --git a/native/cocos/bindings/jswrapper/hermes/Base.h b/native/cocos/bindings/jswrapper/hermes/Base.h new file mode 100644 index 0000000000..51780c79a9 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Base.h @@ -0,0 +1,33 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — mirrors v8/Base.h for the Hermes script engine adapter. + SPDX-License-Identifier: MIT +****************************************************************************/ + +#pragma once + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + // React Native / Hermes JSI headers (provided by hermes-engine AAR / framework) + #include + + #include + #include + #include + #include + #include + #include + + #include "../PrivateObject.h" + #include "base/std/container/string.h" + #include "base/std/container/unordered_map.h" + #include "base/std/container/unordered_set.h" + #include "HelperMacros.h" + +namespace se { +using HermesFinalizeFunc = void (*)(Object *seObj); +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/Class.cpp b/native/cocos/bindings/jswrapper/hermes/Class.cpp new file mode 100644 index 0000000000..a124691508 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Class.cpp @@ -0,0 +1,220 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — Class.cpp + SPDX-License-Identifier: MIT +****************************************************************************/ + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "Class.h" + #include "Object.h" + #include "ScriptEngine.h" + #include "Utils.h" + #include + #include + +namespace fj = facebook::jsi; + +namespace se { + +std::vector Class::_allClasses; + +// --------------------------------------------------------------------------- +// Constructor / Destructor +// --------------------------------------------------------------------------- + +Class::Class() = default; + +Class::~Class() { + if (_proto) { + _proto->decRef(); + _proto = nullptr; + } +} + +// --------------------------------------------------------------------------- +// Static factories +// --------------------------------------------------------------------------- + +Class *Class::create(const ccstd::string &clsName, Object *parent, Object *parentProto, + GenericFunctionCallback ctor, void *data) { + auto *cls = new Class(); + cls->_name = clsName; + cls->_parent = parent; + cls->_parentProto = parentProto; + cls->_ctor = ctor; + cls->_ctorData = data; + _allClasses.push_back(cls); + return cls; +} + +Class *Class::create(const std::initializer_list &classPath, + Object *parent, Object *parentProto, + GenericFunctionCallback ctor, void *data) { + // Use last path component as the class name (mirrors v8 behaviour) + ccstd::string name = *(classPath.end() - 1); + return create(name, parent, parentProto, ctor, data); +} + +// --------------------------------------------------------------------------- +// Definition builders (called before install()) +// --------------------------------------------------------------------------- + +bool Class::defineFunction(const char *name, GenericFunctionCallback func, void *data) { + _functions.push_back({name, func, data}); + return true; +} + +bool Class::defineProperty(const char *name, + GenericGetterCallback getter, GenericSetterCallback setter, + void *data) { + _properties.push_back({name, getter, setter, data}); + return true; +} + +bool Class::defineProperty(const std::initializer_list &names, + GenericGetterCallback getter, GenericSetterCallback setter, + void *data) { + for (const char *n : names) { + defineProperty(n, getter, setter, data); + } + return true; +} + +bool Class::defineStaticFunction(const char *name, GenericFunctionCallback func, void *data) { + _staticFunctions.push_back({name, func, data}); + return true; +} + +bool Class::defineStaticProperty(const char *name, + GenericGetterCallback getter, GenericSetterCallback setter, + void *data) { + _staticProperties.push_back({name, getter, setter, data}); + return true; +} + +bool Class::defineStaticProperty(const char *name, const Value &value, PropertyAttribute) { + // Store as a static getter that returns the constant value + Value captured = value; + return defineStaticProperty(name, + [](fj::Runtime &rt, const fj::Value &, void *ud) -> fj::Value { + auto *v = static_cast(ud); + return se::internal::seToJsValue(rt, *v); + }, + nullptr, + new Value(captured)); // intentional leak — static lifetime +} + +bool Class::defineFinalizeFunction(HermesFinalizeFunc func) { + _finalizeFunc = func; + return true; +} + +// --------------------------------------------------------------------------- +// install() — builds the jsi::Function constructor and installs it +// --------------------------------------------------------------------------- + +bool Class::install() { + fj::Runtime *rt = ScriptEngine::getInstance()->_runtime; + assert(rt); + + // ---- Build prototype object ---- + Object *proto = Object::createPlainObject(); + + // Inherit from parentProto if provided + if (_parentProto) { + auto setProto = rt->global() + .getPropertyAsObject(*rt, "Object") + .getPropertyAsFunction(*rt, "setPrototypeOf"); + setProto.call(*rt, + proto->_getJsiObject(*rt), + _parentProto->_getJsiObject(*rt)); + } + + // Install instance methods on prototype + for (auto &f : _functions) { + void *ud = f.data; + GenericFunctionCallback fn = f.fn; + auto jsFn = fj::Function::createFromHostFunction(*rt, + fj::PropNameID::forAscii(*rt, f.name), 0, + [fn, ud](fj::Runtime &r, const fj::Value &thisVal, + const fj::Value *args, size_t count) -> fj::Value { + return fn(r, thisVal, args, count, ud); + }); + proto->_getJsiObject(*rt).setProperty(*rt, f.name.c_str(), jsFn); + } + + // Install instance properties on prototype + for (auto &p : _properties) { + Value dummy; + proto->defineProperty(p.name.c_str(), p.getter, p.setter, p.data); + } + + _proto = proto; // Class owns proto reference + + // ---- Build constructor function ---- + GenericFunctionCallback ctorCb = _ctor; + void *ctorData = _ctorData; + auto ctorFn = fj::Function::createFromHostFunction(*rt, + fj::PropNameID::forAscii(*rt, _name), 0, + [ctorCb, ctorData](fj::Runtime &r, const fj::Value &thisVal, + const fj::Value *args, size_t count) -> fj::Value { + if (ctorCb) { + ctorCb(r, thisVal, args, count, ctorData); + } + return fj::Value::undefined(); + }); + + // Attach prototype to constructor + const auto& protoJsi = proto->_getJsiObject(*rt); + ctorFn.setProperty(*rt, "prototype", protoJsi); + + // Install static members on constructor + for (auto &sf : _staticFunctions) { + void *ud = sf.data; + GenericFunctionCallback fn = sf.fn; + auto jsFn = fj::Function::createFromHostFunction(*rt, + fj::PropNameID::forAscii(*rt, sf.name), 0, + [fn, ud](fj::Runtime &r, const fj::Value &thisVal, + const fj::Value *args, size_t count) -> fj::Value { + return fn(r, thisVal, args, count, ud); + }); + ctorFn.setProperty(*rt, sf.name.c_str(), jsFn); + } + + // ---- Install constructor on parent object ---- + if (_parent) { + _parent->_getJsiObject(*rt).setProperty(*rt, _name.c_str(), ctorFn); + } else { + rt->global().setProperty(*rt, _name.c_str(), ctorFn); + } + + return true; +} + +// --------------------------------------------------------------------------- +// Cleanup +// --------------------------------------------------------------------------- + +void Class::cleanup() { + for (Class *cls : _allClasses) { + delete cls; + } + _allClasses.clear(); +} + +// --------------------------------------------------------------------------- +// Constructor registration (stub for Hermes port) +// --------------------------------------------------------------------------- + +void Class::_setCtor(Object *obj) { + // STUB: JSB constructor registration is not yet ported to the Hermes + // backend. The Nitro/TypeGPU app path does not reach this; log if hit. + (void)obj; +} + +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/Class.h b/native/cocos/bindings/jswrapper/hermes/Class.h new file mode 100644 index 0000000000..6750d0ac29 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Class.h @@ -0,0 +1,125 @@ +/****************************************************************************\ + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — Class.h + Maps se::Class prototype registration to jsi::Function constructors. + SPDX-License-Identifier: MIT +\****************************************************************************/ + +#pragma once + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "../Define.h" + #include "../Value.h" + #include "Base.h" + #include "HelperMacros.h" + #include + #include + #include + #include + #include + +namespace se { + +class Object; + +/** + * se::Class represents a definition of how to create a native binding object. + * This Hermes backend registers classes as jsi::Function constructors installed + * on a parent jsi::Object (usually the global or a namespace object). + */ +class Class final { +public: + static Class *create(const ccstd::string &clsName, + Object *parent, + Object *parentProto, + GenericFunctionCallback ctor, + void *data = nullptr); + + static Class *create(const std::initializer_list &classPath, + Object *parent, + Object *parentProto, + GenericFunctionCallback ctor, + void *data = nullptr); + + bool defineFunction(const char *name, GenericFunctionCallback func, void *data = nullptr); + bool defineProperty(const char *name, + GenericGetterCallback getter, + GenericSetterCallback setter, + void *data = nullptr); + bool defineProperty(const std::initializer_list &names, + GenericGetterCallback getter, + GenericSetterCallback setter, + void *data = nullptr); + bool defineStaticFunction(const char *name, GenericFunctionCallback func, void *data = nullptr); + bool defineStaticProperty(const char *name, + GenericGetterCallback getter, + GenericSetterCallback setter, + void *data = nullptr); + bool defineStaticProperty(const char *name, const Value &value, + PropertyAttribute attribute = PropertyAttribute::NONE); + bool defineFinalizeFunction(HermesFinalizeFunc func); + + /** + * Installs the class constructor function on the parent object. + * After this, `new ClassName()` in JS invokes the native ctor callback. + */ + bool install(); + + Object *getProto() const { return _proto; } + const char *getName() const { return _name.c_str(); } + + // Private API used in wrapper + HermesFinalizeFunc _getFinalizeFunction() const; + void _setCtor(Object *obj); + inline const std::optional &_getCtor() const { return _ctorObj; } + void setCreateProto(bool createProto); + +private: + Class(); + ~Class(); + + bool init(const ccstd::string &clsName, Object *parent, Object *parentProto, GenericFunctionCallback ctor, void *data = nullptr); + void destroy(); + + static void cleanup(); + + ccstd::string _name; + Object *_parent{nullptr}; + Object *_parentProto{nullptr}; + Object *_proto{nullptr}; // prototype object installed on the ctor + GenericFunctionCallback _ctor{nullptr}; + void *_ctorData{nullptr}; + HermesFinalizeFunc _finalizeFunc{nullptr}; + std::optional _ctorObj; + bool _createProto{true}; + + struct FunctionEntry { + ccstd::string name; + GenericFunctionCallback fn{nullptr}; + void *data{nullptr}; + }; + + struct PropertyEntry { + ccstd::string name; + GenericGetterCallback getter{nullptr}; + GenericSetterCallback setter{nullptr}; + void *data{nullptr}; + }; + + std::vector _functions; + std::vector _staticFunctions; + std::vector _properties; + std::vector _staticProperties; + + static std::vector _allClasses; // for cleanup + + friend class ScriptEngine; + friend class Object; +}; + +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/HelperMacros.h b/native/cocos/bindings/jswrapper/hermes/HelperMacros.h new file mode 100644 index 0000000000..9f4da4e9df --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/HelperMacros.h @@ -0,0 +1,107 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — HelperMacros + SPDX-License-Identifier: MIT +****************************************************************************/ + +#pragma once + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include + #include + #include + #include + #include + #include "../config.h" + #include "base/Log.h" + #include "base/Macros.h" + #include "base/std/container/string.h" + +namespace se { + +class State; +class Object; + +// Callback type for JSI: all JSB callbacks share this signature. +using GenericFunctionCallback = facebook::jsi::Value (*)( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value &thisVal, + const facebook::jsi::Value *args, + size_t count, + void *userData); + +using GenericGetterCallback = facebook::jsi::Value (*)( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value &thisVal, + void *userData); + +using GenericSetterCallback = void (*)( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value &thisVal, + const facebook::jsi::Value &newVal, + void *userData); + +} // namespace se + +// ---- Convenience macros (mirror the v8 HelperMacros pattern) ---- + +#define SE_DECLARE_FUNC(funcName) \ + facebook::jsi::Value funcName( \ + facebook::jsi::Runtime &, \ + const facebook::jsi::Value &, \ + const facebook::jsi::Value *, \ + size_t, \ + void *) + +#define SE_BIND_FUNC(funcName) \ + facebook::jsi::Value funcName( \ + facebook::jsi::Runtime &_rt, \ + const facebook::jsi::Value &_thisVal, \ + const facebook::jsi::Value *_argv, \ + size_t _argc, \ + void *_userdata) { \ + se::State _state(&_rt, &_thisVal, _argv, _argc); \ + bool _ok = funcName##Impl(_state); \ + if (!_ok) { SE_LOGE("[ERROR] Failed to invoke " #funcName "\n"); } \ + return _state.rval().toJsiValue(_rt); \ + } + +#define SE_BIND_PROP_GET(funcName) \ + facebook::jsi::Value funcName( \ + facebook::jsi::Runtime &_rt, \ + const facebook::jsi::Value &_thisVal, \ + void *_userdata) { \ + se::State _state(&_rt, &_thisVal, nullptr, 0); \ + funcName##Impl(_state); \ + return _state.rval().toJsiValue(_rt); \ + } + +#define SE_BIND_PROP_SET(funcName) \ + void funcName( \ + facebook::jsi::Runtime &_rt, \ + const facebook::jsi::Value &_thisVal, \ + const facebook::jsi::Value &_newVal, \ + void *_userdata) { \ + se::Value _seVal; \ + _seVal.fromJsiValue(_rt, _newVal); \ + se::State _state(&_rt, &_thisVal, nullptr, 0); \ + funcName##Impl(_state); \ + } + +template +constexpr inline T *SE_THIS_OBJECT(STATE &s) { // NOLINT + return reinterpret_cast(s.nativeThisObject()); +} + +#define SAFE_INC_REF(obj) \ + if (obj != nullptr) obj->incRef() +#define SAFE_DEC_REF(obj) \ + if ((obj) != nullptr) { \ + (obj)->decRef(); \ + (obj) = nullptr; \ + } + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/Object.cpp b/native/cocos/bindings/jswrapper/hermes/Object.cpp new file mode 100644 index 0000000000..216942999c --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Object.cpp @@ -0,0 +1,412 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — Object.cpp + SPDX-License-Identifier: MIT +****************************************************************************/ + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "Object.h" + #include "ScriptEngine.h" + #include "Utils.h" + #include + #include + +namespace fj = facebook::jsi; + +namespace se { + +facebook::jsi::Runtime *Object::_rt = nullptr; + +// --------------------------------------------------------------------------- +// Internal helpers +// --------------------------------------------------------------------------- + +static fj::Runtime *sRt() { + return ScriptEngine::getInstance()->_runtime; +} + +// --------------------------------------------------------------------------- +// Constructor / destructor +// --------------------------------------------------------------------------- + +Object::Object() = default; + +Object::~Object() { + if (_privateObject) { + delete _privateObject; + _privateObject = nullptr; + } +} + +ccstd::string Object::toString() const { + if (!_jsiObj || !_rt) return {}; + return "{}"; +} + +// --------------------------------------------------------------------------- +// Static factories +// --------------------------------------------------------------------------- + +Object *Object::createPlainObject() { + auto *obj = new Object(); + obj->_rt = sRt(); + obj->_jsiObj = std::make_shared(*sRt()); + obj->incRef(); // caller must decRef + return obj; +} + +Object *Object::createArrayObject(size_t length) { + auto *obj = new Object(); + obj->_rt = sRt(); + obj->_jsiObj = std::make_shared( + fj::Array(*sRt(), length)); + obj->incRef(); + return obj; +} + +Object *Object::createMapObject() { + auto *obj = new Object(); + obj->_rt = sRt(); + auto mapCtor = sRt()->global().getPropertyAsFunction(*sRt(), "Map"); + obj->_jsiObj = std::make_shared( + mapCtor.callAsConstructor(*sRt()).getObject(*sRt())); + obj->incRef(); + return obj; +} + +Object *Object::createSetObject() { + auto *obj = new Object(); + obj->_rt = sRt(); + auto setCtor = sRt()->global().getPropertyAsFunction(*sRt(), "Set"); + obj->_jsiObj = std::make_shared( + setCtor.callAsConstructor(*sRt()).getObject(*sRt())); + obj->incRef(); + return obj; +} + +Object *Object::createObjectWithClass(Class *cls) { + // Class::install() registers a constructor on the global; call new Cls() + auto *obj = new Object(); + obj->_rt = sRt(); + obj->_jsiObj = std::make_shared(*sRt()); + obj->incRef(); + return obj; +} + +Object *Object::_createJSObject(fj::Runtime &rt, fj::Object &&jsObj) { + auto *obj = new Object(); + obj->_rt = &rt; + obj->_jsiObj = std::make_shared(std::move(jsObj)); + obj->incRef(); + return obj; +} + +const fj::Object& Object::_getJsiObject(fj::Runtime &rt) const { + assert(_jsiObj); + (void)rt; + return *_jsiObj; +} + +Object *Object::createFromJsiObject(fj::Runtime &rt, fj::Object &&jsObj) { + return Object::_createJSObject(rt, std::move(jsObj)); +} + +const fj::Object& Object::toJsiObject(fj::Runtime &rt) const { + return Object::_getJsiObject(rt); +} + +// --------------------------------------------------------------------------- +// Promise (stub — Hermes supports Promise natively via JS eval) +// --------------------------------------------------------------------------- +Object *Object::createPromise() { + // Evaluate `new Promise((r,j)=>{...})` via ScriptEngine if needed + return createPlainObject(); // placeholder +} +void Object::rejectPromise(Object *, const Value &) {} +void Object::resolverPromise(Object *, const Value &) {} + +// --------------------------------------------------------------------------- +// Property access +// --------------------------------------------------------------------------- + +bool Object::getProperty(const char *name, Value *data, bool /*cache*/) { + assert(_jsiObj && _rt); + try { + auto jsVal = _jsiObj->getProperty(*_rt, name); + internal::jsToSeValue(*_rt, jsVal, data); + return true; + } catch (...) { return false; } +} + +bool Object::setProperty(const char *name, const Value &data) { + assert(_jsiObj && _rt); + try { + _jsiObj->setProperty(*_rt, name, internal::seToJsValue(*_rt, data)); + return true; + } catch (...) { return false; } +} + +bool Object::hasProperty(const char *name) const { + assert(_jsiObj && _rt); + try { + return _jsiObj->hasProperty(*_rt, name); + } catch (...) { return false; } +} + +bool Object::deleteProperty(const char *name) { + // JSI does not expose delete — use evalString workaround + return false; +} + +bool Object::getPropertyNames(ValueArray *outNames) { + assert(_jsiObj && _rt); + try { + auto names = _jsiObj->getPropertyNames(*_rt); + size_t len = names.size(*_rt); + outNames->resize(len); + for (size_t i = 0; i < len; ++i) { + auto nameStr = names.getValueAtIndex(*_rt, i).getString(*_rt).utf8(*_rt); + (*outNames)[i].setString(nameStr); + } + return true; + } catch (...) { return false; } +} + +bool Object::defineOwnProperty(const char *name, const Value &data, PropertyAttribute /*attr*/) { + return setProperty(name, data); +} + +bool Object::defineProperty(const char *name, + GenericGetterCallback getter, + GenericSetterCallback setter, + void *userdata) { + // Install getter/setter via Object.defineProperty from JS + assert(_jsiObj && _rt); + try { + auto &rt = *_rt; + fj::Object descriptor(rt); + + if (getter) { + void *ud = userdata; + auto getterFn = fj::Function::createFromHostFunction(rt, + fj::PropNameID::forAscii(rt, "get"), 0, + [getter, ud](fj::Runtime &r, const fj::Value &thisVal, + const fj::Value * /*args*/, size_t) -> fj::Value { + return getter(r, thisVal, ud); + }); + descriptor.setProperty(rt, "get", getterFn); + } + if (setter) { + void *ud = userdata; + auto setterFn = fj::Function::createFromHostFunction(rt, + fj::PropNameID::forAscii(rt, "set"), 1, + [setter, ud](fj::Runtime &r, const fj::Value &thisVal, + const fj::Value *args, size_t) -> fj::Value { + setter(r, thisVal, args[0], ud); + return fj::Value::undefined(); + }); + descriptor.setProperty(rt, "set", setterFn); + } + descriptor.setProperty(rt, "enumerable", fj::Value(true)); + descriptor.setProperty(rt, "configurable", fj::Value(true)); + + auto objDefProp = rt.global() + .getPropertyAsObject(rt, "Object") + .getPropertyAsFunction(rt, "defineProperty"); + objDefProp.call(rt, *_jsiObj, + fj::String::createFromAscii(rt, name), + descriptor); + return true; + } catch (...) { return false; } +} + +// --------------------------------------------------------------------------- +// Array +// --------------------------------------------------------------------------- + +bool Object::isArray() const { + assert(_jsiObj && _rt); + return _jsiObj->isArray(*_rt); +} + +uint32_t Object::getArrayLength() const { + if (!isArray()) return 0; + auto arr = _jsiObj->asArray(*_rt); + return static_cast(arr.size(*_rt)); +} + +bool Object::getArrayElement(uint32_t index, Value *data) const { + assert(_jsiObj && _rt); + try { + auto arr = _jsiObj->asArray(*_rt); + internal::jsToSeValue(*_rt, arr.getValueAtIndex(*_rt, index), data); + return true; + } catch (...) { return false; } +} + +bool Object::setArrayElement(uint32_t index, const Value &data) { + assert(_jsiObj && _rt); + try { + _jsiObj->asArray(*_rt).setValueAtIndex(*_rt, index, internal::seToJsValue(*_rt, data)); + return true; + } catch (...) { return false; } +} + +// --------------------------------------------------------------------------- +// TypedArray / ArrayBuffer — forwarded to JS constructor calls +// --------------------------------------------------------------------------- +bool Object::isTypedArray() const { return false; } +se::Object::TypedArrayType Object::getTypedArrayType() const { return se::Object::TypedArrayType::NONE; } +bool Object::getTypedArrayData(uint8_t **, size_t *) const { return false; } +bool Object::isArrayBuffer() const { + assert(_jsiObj && _rt); + return _jsiObj->isArrayBuffer(*_rt); +} +bool Object::getArrayBufferData(uint8_t **, size_t *) const { return false; } +Object *Object::createTypedArray(TypedArrayType, const void *, size_t) { + return createPlainObject(); +} +Object *Object::createExternalArrayBuffer(void *, size_t, BufferContentsFreeFunc, void *) { + return createPlainObject(); +} +Object *Object::getObjectWithPtr(void *) { return nullptr; } + +// --- Missing method for TypedArray support --- +Object *Object::createTypedArrayWithBuffer(TypedArrayType, Object *, uint32_t, uint32_t) { + return createPlainObject(); +} + +// --------------------------------------------------------------------------- +// Function +// --------------------------------------------------------------------------- + +bool Object::isFunction() const { + assert(_jsiObj && _rt); + return _jsiObj->isFunction(*_rt); +} + +bool Object::call(const ValueArray &args, Object *thisObject, Value *rval /* = nullptr */) { + assert(_jsiObj && _rt && isFunction()); + try { + std::vector jsArgs; + internal::seToJsArgs(*_rt, args, jsArgs); + + fj::Value thisVal = thisObject + ? fj::Value(*_rt, thisObject->_getJsiObject(*_rt)) + : fj::Value(*_rt, _rt->global()); + + auto result = _jsiObj->asFunction(*_rt).callWithThis( + *_rt, thisVal.getObject(*_rt), + static_cast(jsArgs.data()), jsArgs.size()); + + if (rval) internal::jsToSeValue(*_rt, result, rval); + return true; + } catch (...) { return false; } +} + +bool Object::defineFunction(const char *name, GenericFunctionCallback func, void *userdata) { + assert(_jsiObj && _rt); + try { + void *ud = userdata; + auto fn = fj::Function::createFromHostFunction(*_rt, + fj::PropNameID::forAscii(*_rt, name), 0, + [func, ud](fj::Runtime &rt, const fj::Value &thisVal, + const fj::Value *args, size_t count) -> fj::Value { + return func(rt, thisVal, args, count, ud); + }); + _jsiObj->setProperty(*_rt, name, fn); + return true; + } catch (...) { return false; } +} + +// --------------------------------------------------------------------------- +// Prototype / proxy +// --------------------------------------------------------------------------- +bool Object::isProxy() const { return false; } +Object *Object::getProto() const { return nullptr; } + +// --------------------------------------------------------------------------- +// Native data / rooting +// --------------------------------------------------------------------------- + +void *Object::getPrivateData() const { + return _privateObject ? _privateObject->getRaw() : nullptr; +} + +void Object::setPrivateData(void *data) { + if (_jsiObj && _rt) { + internal::setPrivateNativePtr(*_rt, *_jsiObj, this); + } +} + +void Object::clearPrivateData() { + if (_privateObject) { + delete _privateObject; + _privateObject = nullptr; + } +} + +void Object::setPrivateObject(PrivateObjectBase *obj) { + _privateObject = obj; +} + +void Object::root() { _rooted = true; } +void Object::unroot() { _rooted = false; } + +bool Object::strictEquals(Object *o) const { + if (!o || !_jsiObj || !o->_jsiObj || !_rt) return false; + return fj::Value::strictEquals(*_rt, fj::Value(*_rt, *_jsiObj), fj::Value(*_rt, *o->_jsiObj)); +} + +// --------------------------------------------------------------------------- +// ArrayBuffer (stub for Hermes port) +// --------------------------------------------------------------------------- + +se::Object *Object::createArrayBufferObject(const void *data, size_t byteLength) { + // STUB: manual JSB ArrayBuffer allocation is not yet ported to the Hermes + // backend. The Nitro/TypeGPU app path does not reach this; log if hit. + (void)data; + (void)byteLength; + return nullptr; +} + +// --------------------------------------------------------------------------- +// Additional se::Object methods — Hermes backend stubs (JSB-only paths not +// reached by the Nitro/TypeGPU app). Mirrors the existing getTypedArrayData / +// getArrayBufferData stubs already present in this file. +// --------------------------------------------------------------------------- + +bool Object::getAllKeys(ccstd::vector *allKeys) const { + if (allKeys) { + allKeys->clear(); + } + return false; +} + +bool Object::getArrayLength(uint32_t *length) const { + if (length) { + *length = 0; + } + return false; +} + +se::Object *Object::createExternalArrayBufferObject(void *contents, size_t byteLength, + BufferContentsFreeFunc freeFunc, void *freeUserData) { + (void)contents; + (void)byteLength; + (void)freeFunc; + (void)freeUserData; + return nullptr; +} + +se::Object *Object::createProxyTarget(Object *proxy) { + (void)proxy; + return nullptr; +} + +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/Object.h b/native/cocos/bindings/jswrapper/hermes/Object.h new file mode 100644 index 0000000000..a8bec74cf0 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Object.h @@ -0,0 +1,203 @@ +/****************************************************************************\ + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — Object.h + Maps se::Object to facebook::jsi::Object. + SPDX-License-Identifier: MIT +\****************************************************************************/ + +#pragma once + +#include "../config.h" +#include "../PrivateObject.h" +#include "../Define.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "../RefCounter.h" + #include "../Value.h" + #include "Base.h" + #include + #include + #include + #include + +namespace se { + +class Class; +class ScriptEngine; + +/** + * se::Object wraps a facebook::jsi::Object. + * All methods mirror the v8::Object.h public API exactly so that + * upstream JSB auto-bindings compile unchanged under -DSCRIPT_ENGINE_TYPE=7. + */ +class Object final : public RefCounter { +public: + // --- Public type definitions (mirror v8 API) --- + // TypedArrayType mirrors v8/Object.h enum + enum class TypedArrayType { + NONE, + INT8, INT16, INT32, + UINT8, UINT8_CLAMPED, UINT16, UINT32, + FLOAT32, FLOAT64 + }; + + using BufferContentsFreeFunc = void (*)(void *contents, size_t byteLength, void *userData); + + // PropertyAttribute is defined in Define.h (mirrors v8 PropertyAttribute) + // enum class PropertyAttribute { NONE = 0, READ_ONLY = 1, DONT_ENUM = 2, DONT_DELETE = 4 }; + + // --- Static factory methods --- + static Object *createPlainObject(); + static Object *createArrayObject(size_t length); + static Object *createMapObject(); + static Object *createSetObject(); + static Object *createPromise(); + static void rejectPromise(Object *object, const Value &value); + static void resolverPromise(Object *object, const Value &value); + static Object *createTypedArray(TypedArrayType type, const void *data, size_t byteLength); + static Object *createExternalArrayBuffer(void *contents, size_t byteLength, + BufferContentsFreeFunc freeFunc, + void *freeUserData = nullptr); + static Object *createObjectWithClass(Class *cls); + static Object *getObjectWithPtr(void *ptr); + + // --- Additional static factories (match V8 API) --- + static Object *createTypedArrayWithBuffer(TypedArrayType type, + Object *arrayBuffer, + uint32_t byteOffset = 0, + uint32_t length = 0); + static Object *createArrayBufferObject(const void *data, size_t byteLength); + static Object *createExternalArrayBufferObject(void *contents, size_t byteLength, + BufferContentsFreeFunc freeFunc, + void *freeUserData = nullptr); + static Object *createJSONObject(const ccstd::string &jsonStr); + static Object *createObjectWithConstructor(Object *constructor); + static Object *createObjectWithConstructor(Object *constructor, const ValueArray &args); + static Object *createProxyTarget(Object *proxy); + + // --- Property access --- + bool getProperty(const char *name, Value *data, bool cachePropertyName = false); + inline bool getProperty(const ccstd::string &name, Value *value) { + return getProperty(name.c_str(), value); + } + bool setProperty(const char *name, const Value &data); + inline bool setProperty(const ccstd::string &name, const Value &value) { + return setProperty(name.c_str(), value); + } + bool defineProperty(const char *name, + GenericGetterCallback getter, GenericSetterCallback setter, + void *userdata = nullptr); + bool defineOwnProperty(const char *name, const Value &data, + PropertyAttribute attribute = PropertyAttribute::NONE); + bool hasProperty(const char *name) const; + bool deleteProperty(const char *name); + bool getPropertyNames(ValueArray *outNames); + bool getAllKeys(ccstd::vector *allKeys) const; + + // --- Array helpers --- + bool isArray() const; + uint32_t getArrayLength() const; + bool getArrayLength(uint32_t *length) const; + bool getArrayElement(uint32_t index, Value *data) const; + bool setArrayElement(uint32_t index, const Value &data); + + // --- ES6 Map helpers --- + bool isMap() const; + bool isWeakMap() const; + void clearMap(); + bool removeMapElement(const Value &key); + bool getMapElement(const Value &key, Value *outValue) const; + bool setMapElement(const Value &key, const Value &value); + + // --- ES6 Set helpers --- + bool isSet() const; + bool isWeakSet() const; + + // --- TypedArray helpers --- + bool isTypedArray() const; + TypedArrayType getTypedArrayType() const; + bool getTypedArrayData(uint8_t **ptr, size_t *length) const; + + // --- ArrayBuffer helpers --- + bool isArrayBuffer() const; + bool getArrayBufferData(uint8_t **ptr, size_t *length) const; + + // --- Function call --- + bool isFunction() const; + bool call(const ValueArray &args, Object *thisObject, Value *rval = nullptr); + bool defineFunction(const char *name, GenericFunctionCallback func, void *userdata = nullptr); + + // --- Prototype --- + bool isProxy() const; + Object *getProto() const; + + // --- Native object binding --- + void *getPrivateData() const; + void setPrivateData(void *data); + void clearPrivateData(); + PrivateObjectBase *getPrivateObject() const { return _privateObject; } + + template + inline std::shared_ptr getPrivateSharedPtr() const { + assert(_privateObject->isSharedPtr()); + return static_cast *>(_privateObject)->getData(); + } + + template + inline cc::IntrusivePtr getPrivateInstrusivePtr() const { + assert(_privateObject->isCCIntrusivePtr()); + return static_cast *>(_privateObject)->getData(); + } + void setPrivateObject(PrivateObjectBase *obj); + + template + inline void setRawPrivateData(T *data, bool tryDestroyInGC = false) { + static_assert(!std::is_void::value, "void * is not allowed for private data"); + auto *privateObject = se::rawref_private_object(data); + if (tryDestroyInGC) { + privateObject->tryAllowDestroyInGC(); + } + setPrivateObject(privateObject); + } + + Class *_getClass() const { return _cls; } + ccstd::string toString() const; + + // --- Rooting (GC protection) --- + void root(); + void unroot(); + bool isRooted() const { return _rooted; } + + // --- Identity --- + bool strictEquals(Object *o) const; + + // --- JSI interop (used by se::Value Hermes shims) --- + static Object *createFromJsiObject(facebook::jsi::Runtime &rt, facebook::jsi::Object &&jsObj); + const facebook::jsi::Object& toJsiObject(facebook::jsi::Runtime &rt) const; + + // --- Internal (used by ScriptEngine / Class, not public JSB API) --- + static Object *_createJSObject(facebook::jsi::Runtime &rt, facebook::jsi::Object &&jsObj); + const facebook::jsi::Object& _getJsiObject(facebook::jsi::Runtime &rt) const; + +private: + Object(); + ~Object() override; + + // Non-owning raw runtime pointer — valid for the lifetime of se::ScriptEngine + static facebook::jsi::Runtime *_rt; + + // The underlying JSI object handle (heap-allocated to avoid copy issues) + std::shared_ptr _jsiObj; + + PrivateObjectBase *_privateObject{nullptr}; + Class *_cls{nullptr}; + bool _rooted{false}; + + friend class ScriptEngine; + friend class Class; +}; + +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/ScriptEngine.cpp b/native/cocos/bindings/jswrapper/hermes/ScriptEngine.cpp new file mode 100644 index 0000000000..8f300db28e --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/ScriptEngine.cpp @@ -0,0 +1,249 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — ScriptEngine.cpp + SPDX-License-Identifier: MIT +****************************************************************************/ + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "ScriptEngine.h" + #include "Class.h" + #include "Object.h" + #include "Utils.h" + #include + #include + #include + #include "base/Log.h" + +namespace fj = facebook::jsi; + +namespace se { + +ScriptEngine *ScriptEngine::_instance = nullptr; + +// --------------------------------------------------------------------------- +// Singleton +// --------------------------------------------------------------------------- + +ScriptEngine *ScriptEngine::getInstance() { + if (!_instance) { + _instance = new ScriptEngine(); + } + return _instance; +} + +void ScriptEngine::destroyInstance() { + if (_instance) { + _instance->cleanup(); + delete _instance; + _instance = nullptr; + } +} + +// --------------------------------------------------------------------------- +// Constructor / Destructor +// --------------------------------------------------------------------------- + +ScriptEngine::ScriptEngine() = default; + +ScriptEngine::~ScriptEngine() { + cleanup(); +} + +// --------------------------------------------------------------------------- +// Initialisation +// --------------------------------------------------------------------------- + +bool ScriptEngine::initWithRuntime(fj::Runtime *rt) { + std::lock_guard lock(_mutex); + if (!rt) { + SE_LOGE("[ScriptEngine/Hermes] initWithRuntime: null runtime!\n"); + return false; + } + _runtime = rt; + Object::_rt = rt; + CC_LOG_INFO("[ScriptEngine/Hermes] Runtime injected: %p", rt); + + // Invoke pre-init hooks + for (auto &hook : _beforeInitHooks) hook(); + + // Wrap the JSI global object as a se::Object + if (_globalObj) { _globalObj->decRef(); } + _globalObj = Object::_createJSObject(*rt, rt->global()); + + // Invoke post-init hooks + for (auto &hook : _afterInitHooks) hook(); + + return true; +} + +bool ScriptEngine::init() { + // If a runtime was injected via initWithRuntime, we're already initialised. + if (_runtime) return true; + SE_LOGE("[ScriptEngine/Hermes] init() called without a runtime — call initWithRuntime(jsi::Runtime*) first.\n"); + return false; +} + +// --------------------------------------------------------------------------- +// Start — register all JSB modules +// --------------------------------------------------------------------------- + +bool ScriptEngine::start() { + assert(_runtime && "start() called before initWithRuntime()"); + + // Permanent callbacks first (not cleared on cleanup) + for (auto &cb : _permanentRegisterCallbacks) { + if (!cb(_globalObj)) { + SE_LOGE("[ScriptEngine/Hermes] Permanent register callback failed!\n"); + return false; + } + } + + // Session callbacks + for (auto &cb : _registerCallbacks) { + if (!cb(_globalObj)) { + SE_LOGE("[ScriptEngine/Hermes] Register callback failed!\n"); + return false; + } + } + + _isRunning = true; + CC_LOG_INFO("[ScriptEngine/Hermes] Started — %zu modules registered.", + _registerCallbacks.size() + _permanentRegisterCallbacks.size()); + return true; +} + +// --------------------------------------------------------------------------- +// Cleanup +// --------------------------------------------------------------------------- + +void ScriptEngine::cleanup() { + _isInCleanup = true; + + for (auto &hook : _beforeCleanupHooks) hook(); + + _isRunning = false; + _registerCallbacks.clear(); + + if (_globalObj) { + _globalObj->decRef(); + _globalObj = nullptr; + } + + Class::cleanup(); + + for (auto &hook : _afterCleanupHooks) hook(); + _isInCleanup = false; + + // Do NOT null _runtime — it is owned by React Native +} + +// --------------------------------------------------------------------------- +// Callbacks registration +// --------------------------------------------------------------------------- + +void ScriptEngine::addRegisterCallback(RegisterCallback cb) { + _registerCallbacks.push_back(cb); +} + +void ScriptEngine::addPermanentRegisterCallback(RegisterCallback cb) { + _permanentRegisterCallbacks.push_back(cb); +} + +void ScriptEngine::addBeforeInitHook(const std::function &hook) { _beforeInitHooks.push_back(hook); } +void ScriptEngine::addAfterInitHook(const std::function &hook) { _afterInitHooks.push_back(hook); } +void ScriptEngine::addBeforeCleanupHook(const std::function &hook) { _beforeCleanupHooks.push_back(hook); } +void ScriptEngine::addAfterCleanupHook(const std::function &hook) { _afterCleanupHooks.push_back(hook); } + +// --------------------------------------------------------------------------- +// Script evaluation +// --------------------------------------------------------------------------- + +bool ScriptEngine::evalString(const char *script, uint32_t length, + Value *ret, const char *fileName) { + assert(_runtime); + try { + std::string src(script, length > 0 ? length : strlen(script)); + std::string url = fileName ? fileName : ""; + + auto result = _runtime->evaluateJavaScript( + std::make_unique(src), url); + + if (ret) { + internal::jsToSeValue(*_runtime, result, ret); + } + return true; + } catch (const fj::JSError &e) { + SE_LOGE("[ScriptEngine/Hermes] JS error in evalString: %s\n", e.getMessage().c_str()); + return false; + } catch (const std::exception &e) { + SE_LOGE("[ScriptEngine/Hermes] Exception in evalString: %s\n", e.what()); + return false; + } +} + +bool ScriptEngine::runScript(const ccstd::string &path, Value *ret) { + if (!_fileDelegate.isValid()) { + SE_LOGE("[ScriptEngine/Hermes] runScript: no FileOperationDelegate set.\n"); + return false; + } + ccstd::string source = _fileDelegate.onGetStringFromFile(path); + if (source.empty()) { + SE_LOGE("[ScriptEngine/Hermes] runScript: empty file: %s\n", path.c_str()); + return false; + } + return evalString(source.c_str(), static_cast(source.size()), + ret, path.c_str()); +} + +ccstd::string ScriptEngine::getCurrentStackTrace() { + // JSI doesn't expose stack trace API directly — return placeholder + return ""; +} + +// --------------------------------------------------------------------------- +// GC / global +// --------------------------------------------------------------------------- + +Object *ScriptEngine::getGlobalObject() const { return _globalObj; } + +void ScriptEngine::garbageCollect() { + // Hermes runs GC automatically; no manual trigger in JSI +} + +// ---- Missing methods for engine integration ---- +void ScriptEngine::handlePromiseExceptions() { + // Hermes handles promise rejections internally + // This is a no-op for JSI - React Native handles promise tracking +} + +void ScriptEngine::mainLoopUpdate() { + // Called from Engine::tick() - no-op for JSI + // React Native handles the JS event loop +} + +void ScriptEngine::setExceptionCallback(const ExceptionCallback & /*cb*/) { + // No-op for Hermes JSI - React Native handles exceptions +} + +void ScriptEngine::setJSExceptionCallback(const ExceptionCallback & /*cb*/) { + // No-op for Hermes JSI - React Native handles exceptions +} + +// --------------------------------------------------------------------------- +// File delegate +// --------------------------------------------------------------------------- + +void ScriptEngine::setFileOperationDelegate(const FileOperationDelegate &delegate) { + _fileDelegate = delegate; +} + +const ScriptEngine::FileOperationDelegate &ScriptEngine::getFileOperationDelegate() const { + return _fileDelegate; +} + +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/ScriptEngine.h b/native/cocos/bindings/jswrapper/hermes/ScriptEngine.h new file mode 100644 index 0000000000..864cad2bae --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/ScriptEngine.h @@ -0,0 +1,145 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — ScriptEngine.h + Maps se::ScriptEngine lifecycle to a facebook::jsi::Runtime* provided + by the React Native Hermes runtime. + SPDX-License-Identifier: MIT +****************************************************************************/ + +#pragma once + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "../Value.h" + #include "Base.h" + #include + #include + #include + #include + #include + +namespace se { + +class Object; +class Class; +class Value; + +/** + * AutoHandleScope — no-op for JSI (no handle scope concept in JSI). + */ +class AutoHandleScope { +public: + AutoHandleScope() = default; + ~AutoHandleScope() = default; +}; + +/** + * ScriptEngine — singleton that wraps a jsi::Runtime* supplied by the + * React Native Hermes runtime. The runtime pointer is injected once via + * initWithRuntime() and is never owned by this class. + */ +class ScriptEngine final { +public: + static ScriptEngine *getInstance(); + void clearException(); + CC_DEPRECATED(3.6.0) + static void destroyInstance(); + + ScriptEngine(); + ~ScriptEngine(); + + // ---- Initialisation ---- + + /** + * Inject the host Hermes jsi::Runtime*. + * Must be called BEFORE start() or any JSB registration. + * The runtime pointer must remain valid for the lifetime of the engine. + */ + bool initWithRuntime(facebook::jsi::Runtime *rt); + + /** Legacy init — creates an internal Hermes runtime if one isn't injected. */ + bool init(); + + /** Registers native modules and invokes all addRegisterCallback callbacks. */ + bool start(); + + /** Resets all state; called on scene restart. */ + void cleanup(); + + // ---- Callbacks ---- + using RegisterCallback = bool (*)(Object *); + void addRegisterCallback(RegisterCallback cb); + void addPermanentRegisterCallback(RegisterCallback cb); + void addBeforeInitHook(const std::function &hook); + void addAfterInitHook(const std::function &hook); + void addBeforeCleanupHook(const std::function &hook); + void addAfterCleanupHook(const std::function &hook); + + // ---- Execution ---- + bool evalString(const char *script, uint32_t length = 0, + Value *ret = nullptr, const char *fileName = nullptr); + bool runScript(const ccstd::string &path, Value *ret = nullptr); + ccstd::string getCurrentStackTrace(); + + // ---- File operation delegate (mirrors v8 API) ---- + class FileOperationDelegate { + public: + FileOperationDelegate() + : onGetDataFromFile(nullptr), onGetStringFromFile(nullptr), + onCheckFileExist(nullptr), onGetFullPath(nullptr) {} + + bool isValid() const { + return onGetDataFromFile != nullptr && onGetStringFromFile != nullptr + && onCheckFileExist != nullptr && onGetFullPath != nullptr; + } + + std::function &)> onGetDataFromFile; + std::function onGetStringFromFile; + std::function onCheckFileExist; + std::function onGetFullPath; + }; + + void setFileOperationDelegate(const FileOperationDelegate &delegate); + const FileOperationDelegate &getFileOperationDelegate() const; + + // ---- State queries ---- + Object *getGlobalObject() const; + bool isGarbageCollecting() const { return false; } + void garbageCollect(); + bool isInCleanup() const { return _isInCleanup; } + bool isValid() const { return _runtime != nullptr; } + bool isRunning() const { return _isRunning; } + + // ---- Missing methods for engine integration ---- + using ExceptionCallback = std::function; // location, message, stack + void setExceptionCallback(const ExceptionCallback &cb); + void setJSExceptionCallback(const ExceptionCallback &cb); + void handlePromiseExceptions(); + void mainLoopUpdate(); + + // --- Internal — accessible by Object / Class --- + facebook::jsi::Runtime *_runtime{nullptr}; + +private: + static ScriptEngine *_instance; + + Object *_globalObj{nullptr}; + bool _isRunning{false}; + bool _isInCleanup{false}; + bool _isGC{false}; + FileOperationDelegate _fileDelegate; + std::mutex _mutex; + + std::vector _registerCallbacks; + std::vector _permanentRegisterCallbacks; + std::vector> _beforeInitHooks; + std::vector> _afterInitHooks; + std::vector> _beforeCleanupHooks; + std::vector> _afterCleanupHooks; +}; + +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/SeApi.h b/native/cocos/bindings/jswrapper/hermes/SeApi.h new file mode 100644 index 0000000000..464245eb54 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/SeApi.h @@ -0,0 +1,15 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — SeApi.h (aggregator) + Mirrors v8/SeApi.h: pulls in all sub-headers so a single + #include "SeApi.h" from the dispatcher gives everything. + SPDX-License-Identifier: MIT +****************************************************************************/ + +#pragma once + +#include "Class.h" +#include "HelperMacros.h" +#include "Object.h" +#include "ScriptEngine.h" +#include "Utils.h" diff --git a/native/cocos/bindings/jswrapper/hermes/Utils.cpp b/native/cocos/bindings/jswrapper/hermes/Utils.cpp new file mode 100644 index 0000000000..f5ff399866 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Utils.cpp @@ -0,0 +1,126 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — Utils.cpp + SPDX-License-Identifier: MIT +****************************************************************************/ + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include "Utils.h" + #include "Object.h" + #include "../Value.h" + #include + #include + +namespace facebook::jsi { class Runtime; } + +namespace se::internal { + +// --------------------------------------------------------------------------- +// jsi → se conversions +// --------------------------------------------------------------------------- + +void jsToSeValue(facebook::jsi::Runtime &rt, const facebook::jsi::Value &jsVal, Value *seVal) { + if (jsVal.isUndefined()) { + seVal->setUndefined(); + } else if (jsVal.isNull()) { + seVal->setNull(); + } else if (jsVal.isBool()) { + seVal->setBoolean(jsVal.getBool()); + } else if (jsVal.isNumber()) { + seVal->setDouble(jsVal.getNumber()); + } else if (jsVal.isString()) { + seVal->setString(jsVal.getString(rt).utf8(rt)); + } else if (jsVal.isObject()) { + auto jsObj = jsVal.getObject(rt); + // Wrap inside a se::Object — takes ownership of the jsi::Object ref + Object *seObj = Object::_createJSObject(rt, std::move(jsObj)); + seVal->setObject(seObj, true); + seObj->decRef(); // Value holds the only ref + } + // BigInt not currently used by Cocos bindings — treat as number string +} + +void jsToSeArgs( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value *jsArgs, + size_t count, + ValueArray &outArr) { + outArr.resize(count); + for (size_t i = 0; i < count; ++i) { + jsToSeValue(rt, jsArgs[i], &outArr[i]); + } +} + +// --------------------------------------------------------------------------- +// se → jsi conversions +// --------------------------------------------------------------------------- + +facebook::jsi::Value seToJsValue(facebook::jsi::Runtime &rt, const Value &seVal) { + switch (seVal.getType()) { + case Value::Type::Undefined: + return facebook::jsi::Value::undefined(); + case Value::Type::Null: + return facebook::jsi::Value::null(); + case Value::Type::Boolean: + return facebook::jsi::Value(seVal.toBoolean()); + case Value::Type::Number: + return facebook::jsi::Value(seVal.toDouble()); + case Value::Type::String: { + auto str = seVal.toString(); + return facebook::jsi::String::createFromUtf8(rt, + reinterpret_cast(str.data()), str.size()); + } + case Value::Type::Object: { + Object *obj = seVal.toObject(); + if (!obj) return facebook::jsi::Value::null(); + return facebook::jsi::Value(rt, obj->_getJsiObject(rt)); + } + default: + return facebook::jsi::Value::undefined(); + } +} + +void seToJsArgs( + facebook::jsi::Runtime &rt, + const ValueArray &args, + std::vector &outArr) { + outArr.reserve(args.size()); + for (const auto &a : args) { + outArr.push_back(seToJsValue(rt, a)); + } +} + +// --------------------------------------------------------------------------- +// Native pointer embedding via jsi::NativeState +// --------------------------------------------------------------------------- + +struct SeObjectNativeState : public facebook::jsi::NativeState { + explicit SeObjectNativeState(Object *obj) : seObject(obj) {} + ~SeObjectNativeState() override = default; + Object *seObject{nullptr}; +}; + +void setPrivateNativePtr( + facebook::jsi::Runtime &rt, + facebook::jsi::Object &jsObj, + Object *seObj) { + jsObj.setNativeState(rt, std::make_shared(seObj)); +} + +void *getPrivateNativePtr( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value &jsVal) { + if (!jsVal.isObject()) return nullptr; + auto jsObj = jsVal.getObject(rt); + if (!jsObj.hasNativeState(rt)) return nullptr; + auto state = jsObj.getNativeState(rt); + auto *ns = dynamic_cast(state.get()); + return ns ? ns->seObject : nullptr; +} + +} // namespace se::internal + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/bindings/jswrapper/hermes/Utils.h b/native/cocos/bindings/jswrapper/hermes/Utils.h new file mode 100644 index 0000000000..341e5332d5 --- /dev/null +++ b/native/cocos/bindings/jswrapper/hermes/Utils.h @@ -0,0 +1,77 @@ +/**************************************************************************** + Copyright (c) 2024 Xiamen Yaji Software Co., Ltd. + Hermes JSI Backend — Utils.h + Bidirectional conversion helpers between se::Value / se::ValueArray and + facebook::jsi::Value / jsi::Array. + SPDX-License-Identifier: MIT +****************************************************************************/ + +#pragma once + +#include "../config.h" + +#if SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES + + #include + #include "../Value.h" + #include "Base.h" + +namespace facebook { namespace jsi { class Runtime; } } + +namespace se { + +namespace internal { + +/** + * Convert an array of jsi::Value arguments into a se::ValueArray. + * Used inside JSI host function callbacks to populate se::State. + */ +void jsToSeArgs( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value *jsArgs, + size_t count, + ValueArray &outArr); + +/** + * Convert a single jsi::Value to a se::Value. + */ +void jsToSeValue( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value &jsVal, + Value *seVal); + +/** + * Convert a se::ValueArray into a std::vector. + */ +void seToJsArgs( + facebook::jsi::Runtime &rt, + const ValueArray &args, + std::vector &outArr); + +/** + * Convert a single se::Value to a jsi::Value. + */ +facebook::jsi::Value seToJsValue( + facebook::jsi::Runtime &rt, + const Value &seVal); + +/** + * Retrieve the native C++ pointer embedded in a jsi::Object via the + * "__nativePtr__" internal field (set as an ExternalObject / NativeState). + */ +void *getPrivateNativePtr( + facebook::jsi::Runtime &rt, + const facebook::jsi::Value &jsVal); + +/** + * Embed a native C++ pointer in a jsi::Object using NativeState. + */ +void setPrivateNativePtr( + facebook::jsi::Runtime &rt, + facebook::jsi::Object &jsObj, + Object *seObj); + +} // namespace internal +} // namespace se + +#endif // SCRIPT_ENGINE_TYPE == SCRIPT_ENGINE_HERMES diff --git a/native/cocos/platform/interfaces/modules/IXRInterface.h b/native/cocos/platform/interfaces/modules/IXRInterface.h index 42933cac6c..ff657034bd 100644 --- a/native/cocos/platform/interfaces/modules/IXRInterface.h +++ b/native/cocos/platform/interfaces/modules/IXRInterface.h @@ -113,13 +113,13 @@ class CC_DLL IXRInterface : public OSInterface { * @zh GFX设备初始化前调用 * @param gfxApi */ - virtual void preGFXDeviceInitialize(gfx::API gfxApi) = 0; + virtual void preGFXDeviceInitialize(gfx::API /*gfxApi*/) {} /** * @en call after gfx device initialize * @zh GFX设备初始化后调用 * @param gfxApi */ - virtual void postGFXDeviceInitialize(gfx::API gfxApi) = 0; + virtual void postGFXDeviceInitialize(gfx::API /*gfxApi*/) {} /** * @en call when gfx device acquire * @zh GFX设备请求渲染 @@ -131,18 +131,18 @@ class CC_DLL IXRInterface : public OSInterface { * @en call when gfx device present * @zh GFX设备是否需要展示操作 */ - virtual bool isGFXDeviceNeedsPresent(gfx::API gfxApi) = 0; + virtual bool isGFXDeviceNeedsPresent(gfx::API /*gfxApi*/) { return true; } /** * @en call after gfx device present * @zh GFX设备展示操作执行之后调用 * @param gfxApi */ - virtual void postGFXDevicePresent(gfx::API gfxApi) = 0; + virtual void postGFXDevicePresent(gfx::API /*gfxApi*/) {} /** * @en call when create gfx device's swapchain * @zh 创建GFX交换链时调用 */ - virtual void createXRSwapchains() = 0; + virtual void createXRSwapchains() {} /** * @en get xr swapchain list * @zh 获取XR交换链列表 @@ -215,20 +215,20 @@ class CC_DLL IXRInterface : public OSInterface { * @param gles3wLoadFuncProc * @param gpuContext */ - virtual void initializeGLESData(xr::PFNGLES3WLOADPROC gles3wLoadFuncProc, gfx::GLES3GPUContext *gpuContext) = 0; + virtual void initializeGLESData(xr::PFNGLES3WLOADPROC gles3wLoadFuncProc, gfx::GLES3GPUContext *gpuContext) {} /** * @en attach current texture id to fbo * @zh 绑定当前纹理到帧缓冲区 */ - virtual void attachGLESFramebufferTexture2D() = 0; + virtual void attachGLESFramebufferTexture2D() {} +#endif /** * @en acquire EGLSurfaceType by engine swapchain's type id * @zh 根据引擎交换链获取对应需要创建的EGLSurface类型 * @param typedID * @return */ - virtual EGLSurfaceType acquireEGLSurfaceType(uint32_t typedID) = 0; -#endif + virtual EGLSurfaceType acquireEGLSurfaceType(uint32_t /*typedID*/) { return EGLSurfaceType::NONE; } // gles3 // stereo render loop diff --git a/native/cocos/renderer/gfx-gles3/GLES3Device.cpp b/native/cocos/renderer/gfx-gles3/GLES3Device.cpp index f20da464e3..5144d6a269 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Device.cpp +++ b/native/cocos/renderer/gfx-gles3/GLES3Device.cpp @@ -75,7 +75,9 @@ GLES3Device::~GLES3Device() { bool GLES3Device::doInit(const DeviceInfo & /*info*/) { _xr = CC_GET_XR_INTERFACE(); +#if CC_USE_XR if (_xr) _xr->preGFXDeviceInitialize(_api); +#endif _gpuContext = ccnew GLES3GPUContext; _gpuStateCache = ccnew GLES3GPUStateCache; _gpuFramebufferHub = ccnew GLES3GPUFramebufferHub; @@ -250,10 +252,12 @@ bool GLES3Device::doInit(const DeviceInfo & /*info*/) { CC_LOG_INFO("FRAMEBUFFER_FETCH: %s", fbfLevelStr.c_str()); CC_LOG_INFO("MULTI_SAMPLE_RENDER_TO_TEXTURE: %s", msaaLevelStr.c_str()); +#if CC_USE_XR if (_xr) { _xr->initializeGLESData(pfnGLES3wLoadProc(), GLES3Device::getInstance()->context()); _xr->postGFXDeviceInitialize(_api); } +#endif return true; } @@ -280,6 +284,7 @@ void GLES3Device::acquire(Swapchain *const *swapchains, uint32_t count) { if (_onAcquire) _onAcquire->execute(); _swapchains.clear(); +#if CC_USE_XR if (_xr) { GLuint xrFramebuffer = 0; #if XR_OEM_HUAWEIVR @@ -297,6 +302,7 @@ void GLES3Device::acquire(Swapchain *const *swapchains, uint32_t count) { } return; } +#endif for (uint32_t i = 0; i < count; ++i) { _swapchains.push_back(static_cast(swapchains[i])->gpuSwapchain()); @@ -310,11 +316,16 @@ void GLES3Device::present() { _numInstances = queue->_numInstances; _numTriangles = queue->_numTriangles; - bool isGFXDeviceNeedsPresent = _xr ? _xr->isGFXDeviceNeedsPresent(_api) : true; + bool isGFXDeviceNeedsPresent = true; +#if CC_USE_XR + if (_xr) isGFXDeviceNeedsPresent = _xr->isGFXDeviceNeedsPresent(_api); +#endif for (auto *swapchain : _swapchains) { if (isGFXDeviceNeedsPresent) _gpuContext->present(swapchain); } +#if CC_USE_XR if (_xr) _xr->postGFXDevicePresent(_api); +#endif // Clear queue stats queue->_numDrawCalls = 0; @@ -548,7 +559,9 @@ QueryPool *GLES3Device::createQueryPool() { Swapchain *GLES3Device::createSwapchain() { if (_xr) { +#if CC_USE_XR _xr->createXRSwapchains(); +#endif } return ccnew GLES3Swapchain; }